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 LightsailClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "lightsail", &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 AddOn {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "nextSnapshotTimeOfDay")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_snapshot_time_of_day: Option<String>,
#[serde(rename = "snapshotTimeOfDay")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_time_of_day: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddOnRequest {
#[serde(rename = "addOnType")]
pub add_on_type: String,
#[serde(rename = "autoSnapshotAddOnRequest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_snapshot_add_on_request: Option<AutoSnapshotAddOnRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Alarm {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "comparisonOperator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comparison_operator: Option<String>,
#[serde(rename = "contactProtocols")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_protocols: Option<Vec<String>>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "datapointsToAlarm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datapoints_to_alarm: Option<i64>,
#[serde(rename = "evaluationPeriods")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation_periods: Option<i64>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
#[serde(rename = "monitoredResourceInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitored_resource_info: Option<MonitoredResourceInfo>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "notificationEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_enabled: Option<bool>,
#[serde(rename = "notificationTriggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_triggers: Option<Vec<String>>,
#[serde(rename = "period")]
#[serde(skip_serializing_if = "Option::is_none")]
pub period: Option<i64>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "statistic")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statistic: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "threshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold: Option<f64>,
#[serde(rename = "treatMissingData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub treat_missing_data: Option<String>,
#[serde(rename = "unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllocateStaticIpRequest {
#[serde(rename = "staticIpName")]
pub static_ip_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AllocateStaticIpResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachCertificateToDistributionRequest {
#[serde(rename = "certificateName")]
pub certificate_name: String,
#[serde(rename = "distributionName")]
pub distribution_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachCertificateToDistributionResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachDiskRequest {
#[serde(rename = "diskName")]
pub disk_name: String,
#[serde(rename = "diskPath")]
pub disk_path: String,
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachDiskResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachInstancesToLoadBalancerRequest {
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachInstancesToLoadBalancerResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachLoadBalancerTlsCertificateRequest {
#[serde(rename = "certificateName")]
pub certificate_name: String,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachLoadBalancerTlsCertificateResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachStaticIpRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "staticIpName")]
pub static_ip_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachStaticIpResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachedDisk {
#[serde(rename = "path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AutoSnapshotAddOnRequest {
#[serde(rename = "snapshotTimeOfDay")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_time_of_day: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoSnapshotDetails {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "date")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<String>,
#[serde(rename = "fromAttachedDisks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_attached_disks: Option<Vec<AttachedDisk>>,
#[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 AvailabilityZone {
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "zoneName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub zone_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Blueprint {
#[serde(rename = "blueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blueprint_id: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
#[serde(rename = "isActive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(rename = "licenseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_url: Option<String>,
#[serde(rename = "minPower")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_power: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "productUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_url: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "versionCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Bundle {
#[serde(rename = "bundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "cpuCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu_count: Option<i64>,
#[serde(rename = "diskSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_size_in_gb: Option<i64>,
#[serde(rename = "instanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "isActive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "power")]
#[serde(skip_serializing_if = "Option::is_none")]
pub power: Option<i64>,
#[serde(rename = "price")]
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<f32>,
#[serde(rename = "ramSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ram_size_in_gb: Option<f32>,
#[serde(rename = "supportedPlatforms")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_platforms: Option<Vec<String>>,
#[serde(rename = "transferPerMonthInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_per_month_in_gb: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CacheBehavior {
#[serde(rename = "behavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub behavior: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CacheBehaviorPerPath {
#[serde(rename = "behavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub behavior: Option<String>,
#[serde(rename = "path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CacheSettings {
#[serde(rename = "allowedHTTPMethods")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_http_methods: Option<String>,
#[serde(rename = "cachedHTTPMethods")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cached_http_methods: Option<String>,
#[serde(rename = "defaultTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ttl: Option<i64>,
#[serde(rename = "forwardedCookies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarded_cookies: Option<CookieObject>,
#[serde(rename = "forwardedHeaders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarded_headers: Option<HeaderObject>,
#[serde(rename = "forwardedQueryStrings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarded_query_strings: Option<QueryStringObject>,
#[serde(rename = "maximumTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_ttl: Option<i64>,
#[serde(rename = "minimumTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_ttl: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Certificate {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "domainValidationRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_validation_records: Option<Vec<DomainValidationRecord>>,
#[serde(rename = "eligibleToRenew")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eligible_to_renew: Option<String>,
#[serde(rename = "inUseResourceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_use_resource_count: Option<i64>,
#[serde(rename = "issuedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issued_at: Option<f64>,
#[serde(rename = "issuerCA")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer_ca: Option<String>,
#[serde(rename = "keyAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_algorithm: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "notAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_after: Option<f64>,
#[serde(rename = "notBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_before: Option<f64>,
#[serde(rename = "renewalSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_summary: Option<RenewalSummary>,
#[serde(rename = "requestFailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_failure_reason: Option<String>,
#[serde(rename = "revocationReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revocation_reason: Option<String>,
#[serde(rename = "revokedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revoked_at: Option<f64>,
#[serde(rename = "serialNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub serial_number: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "subjectAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_alternative_names: Option<Vec<String>>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CertificateSummary {
#[serde(rename = "certificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "certificateDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_detail: Option<Certificate>,
#[serde(rename = "certificateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_name: Option<String>,
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[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 CloseInstancePublicPortsRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "portInfo")]
pub port_info: PortInfo,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloseInstancePublicPortsResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloudFormationStackRecord {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "destinationInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_info: Option<DestinationInfo>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sourceInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_info: Option<Vec<CloudFormationStackRecordSourceInfo>>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloudFormationStackRecordSourceInfo {
#[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>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContactMethod {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "contactEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_endpoint: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Container {
#[serde(rename = "command")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command: Option<Vec<String>>,
#[serde(rename = "environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<String>,
#[serde(rename = "ports")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ports: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerImage {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "digest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub digest: Option<String>,
#[serde(rename = "image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerService {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "containerServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_service_name: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "currentDeployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_deployment: Option<ContainerServiceDeployment>,
#[serde(rename = "isDisabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_disabled: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "nextDeployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_deployment: Option<ContainerServiceDeployment>,
#[serde(rename = "power")]
#[serde(skip_serializing_if = "Option::is_none")]
pub power: Option<String>,
#[serde(rename = "powerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub power_id: Option<String>,
#[serde(rename = "principalArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal_arn: Option<String>,
#[serde(rename = "privateDomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_domain_name: Option<String>,
#[serde(rename = "publicDomainNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_domain_names: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "scale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scale: Option<i64>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[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 ContainerServiceDeployment {
#[serde(rename = "containers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub containers: Option<::std::collections::HashMap<String, Container>>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "publicEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_endpoint: Option<ContainerServiceEndpoint>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContainerServiceDeploymentRequest {
#[serde(rename = "containers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub containers: Option<::std::collections::HashMap<String, Container>>,
#[serde(rename = "publicEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_endpoint: Option<EndpointRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerServiceEndpoint {
#[serde(rename = "containerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_name: Option<String>,
#[serde(rename = "containerPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_port: Option<i64>,
#[serde(rename = "healthCheck")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check: Option<ContainerServiceHealthCheckConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContainerServiceHealthCheckConfig {
#[serde(rename = "healthyThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub healthy_threshold: Option<i64>,
#[serde(rename = "intervalSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interval_seconds: Option<i64>,
#[serde(rename = "path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "successCodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub success_codes: Option<String>,
#[serde(rename = "timeoutSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_seconds: Option<i64>,
#[serde(rename = "unhealthyThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unhealthy_threshold: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerServiceLogEvent {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerServicePower {
#[serde(rename = "cpuCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu_count: Option<f32>,
#[serde(rename = "isActive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "powerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub power_id: Option<String>,
#[serde(rename = "price")]
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<f32>,
#[serde(rename = "ramSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ram_size_in_gb: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerServiceRegistryLogin {
#[serde(rename = "expiresAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<f64>,
#[serde(rename = "password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "registry")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry: Option<String>,
#[serde(rename = "username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerServicesListResult {
#[serde(rename = "containerServices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_services: Option<Vec<ContainerService>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CookieObject {
#[serde(rename = "cookiesAllowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cookies_allow_list: Option<Vec<String>>,
#[serde(rename = "option")]
#[serde(skip_serializing_if = "Option::is_none")]
pub option: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CopySnapshotRequest {
#[serde(rename = "restoreDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_date: Option<String>,
#[serde(rename = "sourceRegion")]
pub source_region: String,
#[serde(rename = "sourceResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_resource_name: Option<String>,
#[serde(rename = "sourceSnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_snapshot_name: Option<String>,
#[serde(rename = "targetSnapshotName")]
pub target_snapshot_name: String,
#[serde(rename = "useLatestRestorableAutoSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_latest_restorable_auto_snapshot: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CopySnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCertificateRequest {
#[serde(rename = "certificateName")]
pub certificate_name: String,
#[serde(rename = "domainName")]
pub domain_name: String,
#[serde(rename = "subjectAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_alternative_names: Option<Vec<String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCertificateResult {
#[serde(rename = "certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<CertificateSummary>,
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCloudFormationStackRequest {
#[serde(rename = "instances")]
pub instances: Vec<InstanceEntry>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCloudFormationStackResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContactMethodRequest {
#[serde(rename = "contactEndpoint")]
pub contact_endpoint: String,
#[serde(rename = "protocol")]
pub protocol: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContactMethodResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContainerServiceDeploymentRequest {
#[serde(rename = "containers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub containers: Option<::std::collections::HashMap<String, Container>>,
#[serde(rename = "publicEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_endpoint: Option<EndpointRequest>,
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContainerServiceDeploymentResult {
#[serde(rename = "containerService")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_service: Option<ContainerService>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContainerServiceRegistryLoginRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContainerServiceRegistryLoginResult {
#[serde(rename = "registryLogin")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_login: Option<ContainerServiceRegistryLogin>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContainerServiceRequest {
#[serde(rename = "deployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment: Option<ContainerServiceDeploymentRequest>,
#[serde(rename = "power")]
pub power: String,
#[serde(rename = "publicDomainNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_domain_names: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "scale")]
pub scale: i64,
#[serde(rename = "serviceName")]
pub service_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContainerServiceResult {
#[serde(rename = "containerService")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_service: Option<ContainerService>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDiskFromSnapshotRequest {
#[serde(rename = "addOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_ons: Option<Vec<AddOnRequest>>,
#[serde(rename = "availabilityZone")]
pub availability_zone: String,
#[serde(rename = "diskName")]
pub disk_name: String,
#[serde(rename = "diskSnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_snapshot_name: Option<String>,
#[serde(rename = "restoreDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_date: Option<String>,
#[serde(rename = "sizeInGb")]
pub size_in_gb: i64,
#[serde(rename = "sourceDiskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_disk_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "useLatestRestorableAutoSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_latest_restorable_auto_snapshot: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDiskFromSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDiskRequest {
#[serde(rename = "addOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_ons: Option<Vec<AddOnRequest>>,
#[serde(rename = "availabilityZone")]
pub availability_zone: String,
#[serde(rename = "diskName")]
pub disk_name: String,
#[serde(rename = "sizeInGb")]
pub size_in_gb: i64,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDiskResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDiskSnapshotRequest {
#[serde(rename = "diskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_name: Option<String>,
#[serde(rename = "diskSnapshotName")]
pub disk_snapshot_name: String,
#[serde(rename = "instanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDiskSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDistributionRequest {
#[serde(rename = "bundleId")]
pub bundle_id: String,
#[serde(rename = "cacheBehaviorSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_behavior_settings: Option<CacheSettings>,
#[serde(rename = "cacheBehaviors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_behaviors: Option<Vec<CacheBehaviorPerPath>>,
#[serde(rename = "defaultCacheBehavior")]
pub default_cache_behavior: CacheBehavior,
#[serde(rename = "distributionName")]
pub distribution_name: String,
#[serde(rename = "origin")]
pub origin: InputOrigin,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDistributionResult {
#[serde(rename = "distribution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution: Option<LightsailDistribution>,
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDomainEntryRequest {
#[serde(rename = "domainEntry")]
pub domain_entry: DomainEntry,
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDomainEntryResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDomainRequest {
#[serde(rename = "domainName")]
pub domain_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDomainResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInstanceSnapshotRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "instanceSnapshotName")]
pub instance_snapshot_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateInstanceSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInstancesFromSnapshotRequest {
#[serde(rename = "addOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_ons: Option<Vec<AddOnRequest>>,
#[serde(rename = "attachedDiskMapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_disk_mapping: Option<::std::collections::HashMap<String, Vec<DiskMap>>>,
#[serde(rename = "availabilityZone")]
pub availability_zone: String,
#[serde(rename = "bundleId")]
pub bundle_id: String,
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
#[serde(rename = "instanceSnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_snapshot_name: Option<String>,
#[serde(rename = "keyPairName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair_name: Option<String>,
#[serde(rename = "restoreDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_date: Option<String>,
#[serde(rename = "sourceInstanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_instance_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "useLatestRestorableAutoSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_latest_restorable_auto_snapshot: Option<bool>,
#[serde(rename = "userData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_data: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateInstancesFromSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInstancesRequest {
#[serde(rename = "addOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_ons: Option<Vec<AddOnRequest>>,
#[serde(rename = "availabilityZone")]
pub availability_zone: String,
#[serde(rename = "blueprintId")]
pub blueprint_id: String,
#[serde(rename = "bundleId")]
pub bundle_id: String,
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
#[serde(rename = "keyPairName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "userData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_data: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateInstancesResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateKeyPairRequest {
#[serde(rename = "keyPairName")]
pub key_pair_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateKeyPairResult {
#[serde(rename = "keyPair")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair: Option<KeyPair>,
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
#[serde(rename = "privateKeyBase64")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_key_base_64: Option<String>,
#[serde(rename = "publicKeyBase64")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_key_base_64: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLoadBalancerRequest {
#[serde(rename = "certificateAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_alternative_names: Option<Vec<String>>,
#[serde(rename = "certificateDomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_domain_name: Option<String>,
#[serde(rename = "certificateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_name: Option<String>,
#[serde(rename = "healthCheckPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_path: Option<String>,
#[serde(rename = "instancePort")]
pub instance_port: i64,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLoadBalancerResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLoadBalancerTlsCertificateRequest {
#[serde(rename = "certificateAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_alternative_names: Option<Vec<String>>,
#[serde(rename = "certificateDomainName")]
pub certificate_domain_name: String,
#[serde(rename = "certificateName")]
pub certificate_name: String,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLoadBalancerTlsCertificateResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRelationalDatabaseFromSnapshotRequest {
#[serde(rename = "availabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "publiclyAccessible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publicly_accessible: Option<bool>,
#[serde(rename = "relationalDatabaseBundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_bundle_id: Option<String>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "relationalDatabaseSnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_snapshot_name: Option<String>,
#[serde(rename = "restoreTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_time: Option<f64>,
#[serde(rename = "sourceRelationalDatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_relational_database_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "useLatestRestorableTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_latest_restorable_time: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRelationalDatabaseFromSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRelationalDatabaseRequest {
#[serde(rename = "availabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "masterDatabaseName")]
pub master_database_name: String,
#[serde(rename = "masterUserPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_password: Option<String>,
#[serde(rename = "masterUsername")]
pub master_username: String,
#[serde(rename = "preferredBackupWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_backup_window: Option<String>,
#[serde(rename = "preferredMaintenanceWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_maintenance_window: Option<String>,
#[serde(rename = "publiclyAccessible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publicly_accessible: Option<bool>,
#[serde(rename = "relationalDatabaseBlueprintId")]
pub relational_database_blueprint_id: String,
#[serde(rename = "relationalDatabaseBundleId")]
pub relational_database_bundle_id: String,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRelationalDatabaseResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRelationalDatabaseSnapshotRequest {
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "relationalDatabaseSnapshotName")]
pub relational_database_snapshot_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRelationalDatabaseSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAlarmRequest {
#[serde(rename = "alarmName")]
pub alarm_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAlarmResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAutoSnapshotRequest {
#[serde(rename = "date")]
pub date: String,
#[serde(rename = "resourceName")]
pub resource_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAutoSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCertificateRequest {
#[serde(rename = "certificateName")]
pub certificate_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteCertificateResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContactMethodRequest {
#[serde(rename = "protocol")]
pub protocol: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContactMethodResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContainerImageRequest {
#[serde(rename = "image")]
pub image: String,
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContainerImageResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContainerServiceRequest {
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContainerServiceResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDiskRequest {
#[serde(rename = "diskName")]
pub disk_name: String,
#[serde(rename = "forceDeleteAddOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_delete_add_ons: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDiskResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDiskSnapshotRequest {
#[serde(rename = "diskSnapshotName")]
pub disk_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDiskSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDistributionRequest {
#[serde(rename = "distributionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDistributionResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDomainEntryRequest {
#[serde(rename = "domainEntry")]
pub domain_entry: DomainEntry,
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDomainEntryResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDomainRequest {
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDomainResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInstanceRequest {
#[serde(rename = "forceDeleteAddOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_delete_add_ons: Option<bool>,
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInstanceResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInstanceSnapshotRequest {
#[serde(rename = "instanceSnapshotName")]
pub instance_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInstanceSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteKeyPairRequest {
#[serde(rename = "keyPairName")]
pub key_pair_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteKeyPairResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteKnownHostKeysRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteKnownHostKeysResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLoadBalancerRequest {
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLoadBalancerResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLoadBalancerTlsCertificateRequest {
#[serde(rename = "certificateName")]
pub certificate_name: String,
#[serde(rename = "force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLoadBalancerTlsCertificateResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRelationalDatabaseRequest {
#[serde(rename = "finalRelationalDatabaseSnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub final_relational_database_snapshot_name: Option<String>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "skipFinalSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_final_snapshot: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRelationalDatabaseResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRelationalDatabaseSnapshotRequest {
#[serde(rename = "relationalDatabaseSnapshotName")]
pub relational_database_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRelationalDatabaseSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DestinationInfo {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "service")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachCertificateFromDistributionRequest {
#[serde(rename = "distributionName")]
pub distribution_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachCertificateFromDistributionResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachDiskRequest {
#[serde(rename = "diskName")]
pub disk_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachDiskResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachInstancesFromLoadBalancerRequest {
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachInstancesFromLoadBalancerResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachStaticIpRequest {
#[serde(rename = "staticIpName")]
pub static_ip_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachStaticIpResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableAddOnRequest {
#[serde(rename = "addOnType")]
pub add_on_type: String,
#[serde(rename = "resourceName")]
pub resource_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableAddOnResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Disk {
#[serde(rename = "addOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_ons: Option<Vec<AddOn>>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "attachedTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_to: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "isAttached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_attached: Option<bool>,
#[serde(rename = "isSystemDisk")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_system_disk: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DiskInfo {
#[serde(rename = "isSystemDisk")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_system_disk: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DiskMap {
#[serde(rename = "newDiskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_disk_name: Option<String>,
#[serde(rename = "originalDiskPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub original_disk_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DiskSnapshot {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "fromDiskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_disk_arn: Option<String>,
#[serde(rename = "fromDiskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_disk_name: Option<String>,
#[serde(rename = "fromInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_instance_arn: Option<String>,
#[serde(rename = "fromInstanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_instance_name: Option<String>,
#[serde(rename = "isFromAutoSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_from_auto_snapshot: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "progress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DiskSnapshotInfo {
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DistributionBundle {
#[serde(rename = "bundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "isActive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "price")]
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<f32>,
#[serde(rename = "transferPerMonthInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_per_month_in_gb: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Domain {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "domainEntries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_entries: Option<Vec<DomainEntry>>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DomainEntry {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "isAlias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_alias: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: 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 DomainValidationRecord {
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "resourceRecord")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_record: Option<ResourceRecord>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DownloadDefaultKeyPairRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DownloadDefaultKeyPairResult {
#[serde(rename = "privateKeyBase64")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_key_base_64: Option<String>,
#[serde(rename = "publicKeyBase64")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_key_base_64: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableAddOnRequest {
#[serde(rename = "addOnRequest")]
pub add_on_request: AddOnRequest,
#[serde(rename = "resourceName")]
pub resource_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableAddOnResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EndpointRequest {
#[serde(rename = "containerName")]
pub container_name: String,
#[serde(rename = "containerPort")]
pub container_port: i64,
#[serde(rename = "healthCheck")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check: Option<ContainerServiceHealthCheckConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportSnapshotRecord {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "destinationInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_info: Option<DestinationInfo>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sourceInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_info: Option<ExportSnapshotRecordSourceInfo>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportSnapshotRecordSourceInfo {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "diskSnapshotInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_snapshot_info: Option<DiskSnapshotInfo>,
#[serde(rename = "fromResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_resource_arn: Option<String>,
#[serde(rename = "fromResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_resource_name: Option<String>,
#[serde(rename = "instanceSnapshotInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_snapshot_info: Option<InstanceSnapshotInfo>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExportSnapshotRequest {
#[serde(rename = "sourceSnapshotName")]
pub source_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportSnapshotResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetActiveNamesRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetActiveNamesResult {
#[serde(rename = "activeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active_names: Option<Vec<String>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAlarmsRequest {
#[serde(rename = "alarmName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarm_name: Option<String>,
#[serde(rename = "monitoredResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitored_resource_name: Option<String>,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAlarmsResult {
#[serde(rename = "alarms")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarms: Option<Vec<Alarm>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAutoSnapshotsRequest {
#[serde(rename = "resourceName")]
pub resource_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAutoSnapshotsResult {
#[serde(rename = "autoSnapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_snapshots: Option<Vec<AutoSnapshotDetails>>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBlueprintsRequest {
#[serde(rename = "includeInactive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_inactive: Option<bool>,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBlueprintsResult {
#[serde(rename = "blueprints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blueprints: Option<Vec<Blueprint>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBundlesRequest {
#[serde(rename = "includeInactive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_inactive: Option<bool>,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBundlesResult {
#[serde(rename = "bundles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundles: Option<Vec<Bundle>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCertificatesRequest {
#[serde(rename = "certificateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_name: Option<String>,
#[serde(rename = "certificateStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_statuses: Option<Vec<String>>,
#[serde(rename = "includeCertificateDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_certificate_details: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCertificatesResult {
#[serde(rename = "certificates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificates: Option<Vec<CertificateSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCloudFormationStackRecordsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCloudFormationStackRecordsResult {
#[serde(rename = "cloudFormationStackRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_formation_stack_records: Option<Vec<CloudFormationStackRecord>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContactMethodsRequest {
#[serde(rename = "protocols")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocols: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContactMethodsResult {
#[serde(rename = "contactMethods")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_methods: Option<Vec<ContactMethod>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerAPIMetadataRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerAPIMetadataResult {
#[serde(rename = "metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Vec<::std::collections::HashMap<String, String>>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerImagesRequest {
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerImagesResult {
#[serde(rename = "containerImages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_images: Option<Vec<ContainerImage>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerLogRequest {
#[serde(rename = "containerName")]
pub container_name: String,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "filterPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_pattern: Option<String>,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "serviceName")]
pub service_name: String,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerLogResult {
#[serde(rename = "logEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_events: Option<Vec<ContainerServiceLogEvent>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerServiceDeploymentsRequest {
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerServiceDeploymentsResult {
#[serde(rename = "deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<ContainerServiceDeployment>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerServiceMetricDataRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "period")]
pub period: i64,
#[serde(rename = "serviceName")]
pub service_name: String,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "statistics")]
pub statistics: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerServiceMetricDataResult {
#[serde(rename = "metricData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_data: Option<Vec<MetricDatapoint>>,
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerServicePowersRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerServicePowersResult {
#[serde(rename = "powers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub powers: Option<Vec<ContainerServicePower>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerServicesRequest {
#[serde(rename = "serviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDiskRequest {
#[serde(rename = "diskName")]
pub disk_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDiskResult {
#[serde(rename = "disk")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk: Option<Disk>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDiskSnapshotRequest {
#[serde(rename = "diskSnapshotName")]
pub disk_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDiskSnapshotResult {
#[serde(rename = "diskSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_snapshot: Option<DiskSnapshot>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDiskSnapshotsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDiskSnapshotsResult {
#[serde(rename = "diskSnapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_snapshots: Option<Vec<DiskSnapshot>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDisksRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDisksResult {
#[serde(rename = "disks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disks: Option<Vec<Disk>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionBundlesRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDistributionBundlesResult {
#[serde(rename = "bundles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundles: Option<Vec<DistributionBundle>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionLatestCacheResetRequest {
#[serde(rename = "distributionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDistributionLatestCacheResetResult {
#[serde(rename = "createTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionMetricDataRequest {
#[serde(rename = "distributionName")]
pub distribution_name: String,
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "period")]
pub period: i64,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "statistics")]
pub statistics: Vec<String>,
#[serde(rename = "unit")]
pub unit: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDistributionMetricDataResult {
#[serde(rename = "metricData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_data: Option<Vec<MetricDatapoint>>,
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionsRequest {
#[serde(rename = "distributionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_name: Option<String>,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDistributionsResult {
#[serde(rename = "distributions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distributions: Option<Vec<LightsailDistribution>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainRequest {
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainResult {
#[serde(rename = "domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<Domain>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainsResult {
#[serde(rename = "domains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<Domain>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetExportSnapshotRecordsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetExportSnapshotRecordsResult {
#[serde(rename = "exportSnapshotRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_snapshot_records: Option<Vec<ExportSnapshotRecord>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceAccessDetailsRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceAccessDetailsResult {
#[serde(rename = "accessDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_details: Option<InstanceAccessDetails>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceMetricDataRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "period")]
pub period: i64,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "statistics")]
pub statistics: Vec<String>,
#[serde(rename = "unit")]
pub unit: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceMetricDataResult {
#[serde(rename = "metricData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_data: Option<Vec<MetricDatapoint>>,
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstancePortStatesRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstancePortStatesResult {
#[serde(rename = "portStates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_states: Option<Vec<InstancePortState>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceResult {
#[serde(rename = "instance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance: Option<Instance>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceSnapshotRequest {
#[serde(rename = "instanceSnapshotName")]
pub instance_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceSnapshotResult {
#[serde(rename = "instanceSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_snapshot: Option<InstanceSnapshot>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceSnapshotsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceSnapshotsResult {
#[serde(rename = "instanceSnapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_snapshots: Option<Vec<InstanceSnapshot>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstanceStateRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstanceStateResult {
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<InstanceState>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInstancesRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInstancesResult {
#[serde(rename = "instances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances: Option<Vec<Instance>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetKeyPairRequest {
#[serde(rename = "keyPairName")]
pub key_pair_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetKeyPairResult {
#[serde(rename = "keyPair")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair: Option<KeyPair>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetKeyPairsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetKeyPairsResult {
#[serde(rename = "keyPairs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pairs: Option<Vec<KeyPair>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLoadBalancerMetricDataRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "period")]
pub period: i64,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "statistics")]
pub statistics: Vec<String>,
#[serde(rename = "unit")]
pub unit: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLoadBalancerMetricDataResult {
#[serde(rename = "metricData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_data: Option<Vec<MetricDatapoint>>,
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLoadBalancerRequest {
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLoadBalancerResult {
#[serde(rename = "loadBalancer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancer: Option<LoadBalancer>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLoadBalancerTlsCertificatesRequest {
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLoadBalancerTlsCertificatesResult {
#[serde(rename = "tlsCertificates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_certificates: Option<Vec<LoadBalancerTlsCertificate>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLoadBalancersRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLoadBalancersResult {
#[serde(rename = "loadBalancers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancers: Option<Vec<LoadBalancer>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOperationRequest {
#[serde(rename = "operationId")]
pub operation_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOperationResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOperationsForResourceRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "resourceName")]
pub resource_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOperationsForResourceResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOperationsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOperationsResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRegionsRequest {
#[serde(rename = "includeAvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_availability_zones: Option<bool>,
#[serde(rename = "includeRelationalDatabaseAvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_relational_database_availability_zones: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRegionsResult {
#[serde(rename = "regions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub regions: Option<Vec<Region>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseBlueprintsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseBlueprintsResult {
#[serde(rename = "blueprints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blueprints: Option<Vec<RelationalDatabaseBlueprint>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseBundlesRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseBundlesResult {
#[serde(rename = "bundles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundles: Option<Vec<RelationalDatabaseBundle>>,
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseEventsRequest {
#[serde(rename = "durationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration_in_minutes: Option<i64>,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseEventsResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "relationalDatabaseEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_events: Option<Vec<RelationalDatabaseEvent>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseLogEventsRequest {
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "logStreamName")]
pub log_stream_name: String,
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "startFromHead")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_from_head: Option<bool>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseLogEventsResult {
#[serde(rename = "nextBackwardToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_backward_token: Option<String>,
#[serde(rename = "nextForwardToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_forward_token: Option<String>,
#[serde(rename = "resourceLogEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_log_events: Option<Vec<LogEvent>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseLogStreamsRequest {
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseLogStreamsResult {
#[serde(rename = "logStreams")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_streams: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseMasterUserPasswordRequest {
#[serde(rename = "passwordVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password_version: Option<String>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseMasterUserPasswordResult {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "masterUserPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_password: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseMetricDataRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "period")]
pub period: i64,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "statistics")]
pub statistics: Vec<String>,
#[serde(rename = "unit")]
pub unit: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseMetricDataResult {
#[serde(rename = "metricData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_data: Option<Vec<MetricDatapoint>>,
#[serde(rename = "metricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseParametersRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseParametersResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<Vec<RelationalDatabaseParameter>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseRequest {
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseResult {
#[serde(rename = "relationalDatabase")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database: Option<RelationalDatabase>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseSnapshotRequest {
#[serde(rename = "relationalDatabaseSnapshotName")]
pub relational_database_snapshot_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseSnapshotResult {
#[serde(rename = "relationalDatabaseSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_snapshot: Option<RelationalDatabaseSnapshot>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabaseSnapshotsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabaseSnapshotsResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "relationalDatabaseSnapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_snapshots: Option<Vec<RelationalDatabaseSnapshot>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRelationalDatabasesRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRelationalDatabasesResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "relationalDatabases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_databases: Option<Vec<RelationalDatabase>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStaticIpRequest {
#[serde(rename = "staticIpName")]
pub static_ip_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetStaticIpResult {
#[serde(rename = "staticIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub static_ip: Option<StaticIp>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStaticIpsRequest {
#[serde(rename = "pageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetStaticIpsResult {
#[serde(rename = "nextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "staticIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub static_ips: Option<Vec<StaticIp>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HeaderObject {
#[serde(rename = "headersAllowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub headers_allow_list: Option<Vec<String>>,
#[serde(rename = "option")]
#[serde(skip_serializing_if = "Option::is_none")]
pub option: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HostKeyAttributes {
#[serde(rename = "algorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm: Option<String>,
#[serde(rename = "fingerprintSHA1")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fingerprint_sha1: Option<String>,
#[serde(rename = "fingerprintSHA256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fingerprint_sha256: Option<String>,
#[serde(rename = "notValidAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_valid_after: Option<f64>,
#[serde(rename = "notValidBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_valid_before: Option<f64>,
#[serde(rename = "publicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_key: Option<String>,
#[serde(rename = "witnessedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub witnessed_at: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ImportKeyPairRequest {
#[serde(rename = "keyPairName")]
pub key_pair_name: String,
#[serde(rename = "publicKeyBase64")]
pub public_key_base_64: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImportKeyPairResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputOrigin {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "protocolPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_policy: Option<String>,
#[serde(rename = "regionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Instance {
#[serde(rename = "addOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_ons: Option<Vec<AddOn>>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "blueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blueprint_id: Option<String>,
#[serde(rename = "blueprintName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blueprint_name: Option<String>,
#[serde(rename = "bundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "hardware")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hardware: Option<InstanceHardware>,
#[serde(rename = "ipv6Address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_6_address: Option<String>,
#[serde(rename = "isStaticIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_static_ip: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "networking")]
#[serde(skip_serializing_if = "Option::is_none")]
pub networking: Option<InstanceNetworking>,
#[serde(rename = "privateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_address: Option<String>,
#[serde(rename = "publicIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ip_address: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_key_name: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<InstanceState>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceAccessDetails {
#[serde(rename = "certKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cert_key: Option<String>,
#[serde(rename = "expiresAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<f64>,
#[serde(rename = "hostKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_keys: Option<Vec<HostKeyAttributes>>,
#[serde(rename = "instanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
#[serde(rename = "ipAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "passwordData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password_data: Option<PasswordData>,
#[serde(rename = "privateKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_key: Option<String>,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InstanceEntry {
#[serde(rename = "availabilityZone")]
pub availability_zone: String,
#[serde(rename = "instanceType")]
pub instance_type: String,
#[serde(rename = "portInfoSource")]
pub port_info_source: String,
#[serde(rename = "sourceName")]
pub source_name: String,
#[serde(rename = "userData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_data: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceHardware {
#[serde(rename = "cpuCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu_count: Option<i64>,
#[serde(rename = "disks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disks: Option<Vec<Disk>>,
#[serde(rename = "ramSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ram_size_in_gb: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceHealthSummary {
#[serde(rename = "instanceHealth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_health: Option<String>,
#[serde(rename = "instanceHealthReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_health_reason: Option<String>,
#[serde(rename = "instanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceNetworking {
#[serde(rename = "monthlyTransfer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monthly_transfer: Option<MonthlyTransfer>,
#[serde(rename = "ports")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ports: Option<Vec<InstancePortInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstancePortInfo {
#[serde(rename = "accessDirection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_direction: Option<String>,
#[serde(rename = "accessFrom")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_from: Option<String>,
#[serde(rename = "accessType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_type: Option<String>,
#[serde(rename = "cidrListAliases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_list_aliases: Option<Vec<String>>,
#[serde(rename = "cidrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidrs: Option<Vec<String>>,
#[serde(rename = "commonName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub common_name: Option<String>,
#[serde(rename = "fromPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_port: Option<i64>,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "toPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub to_port: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstancePortState {
#[serde(rename = "cidrListAliases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_list_aliases: Option<Vec<String>>,
#[serde(rename = "cidrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidrs: Option<Vec<String>>,
#[serde(rename = "fromPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_port: Option<i64>,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "toPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub to_port: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceSnapshot {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "fromAttachedDisks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_attached_disks: Option<Vec<Disk>>,
#[serde(rename = "fromBlueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_blueprint_id: Option<String>,
#[serde(rename = "fromBundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_bundle_id: Option<String>,
#[serde(rename = "fromInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_instance_arn: Option<String>,
#[serde(rename = "fromInstanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_instance_name: Option<String>,
#[serde(rename = "isFromAutoSnapshot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_from_auto_snapshot: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "progress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceSnapshotInfo {
#[serde(rename = "fromBlueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_blueprint_id: Option<String>,
#[serde(rename = "fromBundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_bundle_id: Option<String>,
#[serde(rename = "fromDiskInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_disk_info: Option<Vec<DiskInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceState {
#[serde(rename = "code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: 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 IsVpcPeeredRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IsVpcPeeredResult {
#[serde(rename = "isPeered")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_peered: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct KeyPair {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "fingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fingerprint: Option<String>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LightsailDistribution {
#[serde(rename = "ableToUpdateBundle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub able_to_update_bundle: Option<bool>,
#[serde(rename = "alternativeDomainNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alternative_domain_names: Option<Vec<String>>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "bundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "cacheBehaviorSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_behavior_settings: Option<CacheSettings>,
#[serde(rename = "cacheBehaviors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_behaviors: Option<Vec<CacheBehaviorPerPath>>,
#[serde(rename = "certificateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_name: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "defaultCacheBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_cache_behavior: Option<CacheBehavior>,
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "isEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_enabled: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "origin")]
#[serde(skip_serializing_if = "Option::is_none")]
pub origin: Option<Origin>,
#[serde(rename = "originPublicDNS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub origin_public_dns: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LoadBalancer {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "configurationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_options: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "dnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_name: Option<String>,
#[serde(rename = "healthCheckPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_path: Option<String>,
#[serde(rename = "instanceHealthSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_health_summary: Option<Vec<InstanceHealthSummary>>,
#[serde(rename = "instancePort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_port: Option<i64>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "publicPorts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ports: Option<Vec<i64>>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "tlsCertificateSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_certificate_summaries: Option<Vec<LoadBalancerTlsCertificateSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LoadBalancerTlsCertificate {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "domainValidationRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_validation_records: Option<Vec<LoadBalancerTlsCertificateDomainValidationRecord>>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "isAttached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_attached: Option<bool>,
#[serde(rename = "issuedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issued_at: Option<f64>,
#[serde(rename = "issuer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<String>,
#[serde(rename = "keyAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_algorithm: Option<String>,
#[serde(rename = "loadBalancerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancer_name: Option<String>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "notAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_after: Option<f64>,
#[serde(rename = "notBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_before: Option<f64>,
#[serde(rename = "renewalSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_summary: Option<LoadBalancerTlsCertificateRenewalSummary>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "revocationReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revocation_reason: Option<String>,
#[serde(rename = "revokedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revoked_at: Option<f64>,
#[serde(rename = "serial")]
#[serde(skip_serializing_if = "Option::is_none")]
pub serial: Option<String>,
#[serde(rename = "signatureAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signature_algorithm: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "subject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
#[serde(rename = "subjectAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_alternative_names: Option<Vec<String>>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LoadBalancerTlsCertificateDomainValidationOption {
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "validationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LoadBalancerTlsCertificateDomainValidationRecord {
#[serde(rename = "domainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: 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 = "validationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_status: 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 LoadBalancerTlsCertificateRenewalSummary {
#[serde(rename = "domainValidationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_validation_options: Option<Vec<LoadBalancerTlsCertificateDomainValidationOption>>,
#[serde(rename = "renewalStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LoadBalancerTlsCertificateSummary {
#[serde(rename = "isAttached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_attached: 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 LogEvent {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MetricDatapoint {
#[serde(rename = "average")]
#[serde(skip_serializing_if = "Option::is_none")]
pub average: Option<f64>,
#[serde(rename = "maximum")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum: Option<f64>,
#[serde(rename = "minimum")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum: Option<f64>,
#[serde(rename = "sampleCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_count: Option<f64>,
#[serde(rename = "sum")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sum: Option<f64>,
#[serde(rename = "timestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<f64>,
#[serde(rename = "unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonitoredResourceInfo {
#[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>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonthlyTransfer {
#[serde(rename = "gbPerMonthAllocated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gb_per_month_allocated: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OpenInstancePublicPortsRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "portInfo")]
pub port_info: PortInfo,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OpenInstancePublicPortsResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Operation {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<String>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "isTerminal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_terminal: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "operationDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_details: Option<String>,
#[serde(rename = "operationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_type: Option<String>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusChangedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_changed_at: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Origin {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "protocolPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_policy: Option<String>,
#[serde(rename = "regionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PasswordData {
#[serde(rename = "ciphertext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ciphertext: Option<String>,
#[serde(rename = "keyPairName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PeerVpcRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PeerVpcResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PendingMaintenanceAction {
#[serde(rename = "action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "currentApplyDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_apply_date: Option<f64>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PendingModifiedRelationalDatabaseValues {
#[serde(rename = "backupRetentionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_retention_enabled: Option<bool>,
#[serde(rename = "engineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "masterUserPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_password: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PortInfo {
#[serde(rename = "cidrListAliases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_list_aliases: Option<Vec<String>>,
#[serde(rename = "cidrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidrs: Option<Vec<String>>,
#[serde(rename = "fromPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_port: Option<i64>,
#[serde(rename = "protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "toPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub to_port: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAlarmRequest {
#[serde(rename = "alarmName")]
pub alarm_name: String,
#[serde(rename = "comparisonOperator")]
pub comparison_operator: String,
#[serde(rename = "contactProtocols")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_protocols: Option<Vec<String>>,
#[serde(rename = "datapointsToAlarm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datapoints_to_alarm: Option<i64>,
#[serde(rename = "evaluationPeriods")]
pub evaluation_periods: i64,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "monitoredResourceName")]
pub monitored_resource_name: String,
#[serde(rename = "notificationEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_enabled: Option<bool>,
#[serde(rename = "notificationTriggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_triggers: Option<Vec<String>>,
#[serde(rename = "threshold")]
pub threshold: f64,
#[serde(rename = "treatMissingData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub treat_missing_data: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAlarmResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutInstancePublicPortsRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
#[serde(rename = "portInfos")]
pub port_infos: Vec<PortInfo>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutInstancePublicPortsResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct QueryStringObject {
#[serde(rename = "option")]
#[serde(skip_serializing_if = "Option::is_none")]
pub option: Option<bool>,
#[serde(rename = "queryStringsAllowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_strings_allow_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebootInstanceRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RebootInstanceResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebootRelationalDatabaseRequest {
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RebootRelationalDatabaseResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Region {
#[serde(rename = "availabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zones: Option<Vec<AvailabilityZone>>,
#[serde(rename = "continentCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub continent_code: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "displayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "relationalDatabaseAvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_availability_zones: Option<Vec<AvailabilityZone>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterContainerImageRequest {
#[serde(rename = "digest")]
pub digest: String,
#[serde(rename = "label")]
pub label: String,
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterContainerImageResult {
#[serde(rename = "containerImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_image: Option<ContainerImage>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabase {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "backupRetentionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_retention_enabled: Option<bool>,
#[serde(rename = "caCertificateIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ca_certificate_identifier: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "engineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "hardware")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hardware: Option<RelationalDatabaseHardware>,
#[serde(rename = "latestRestorableTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_restorable_time: Option<f64>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "masterDatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_database_name: Option<String>,
#[serde(rename = "masterEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_endpoint: Option<RelationalDatabaseEndpoint>,
#[serde(rename = "masterUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_username: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "parameterApplyStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_apply_status: Option<String>,
#[serde(rename = "pendingMaintenanceActions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_maintenance_actions: Option<Vec<PendingMaintenanceAction>>,
#[serde(rename = "pendingModifiedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_modified_values: Option<PendingModifiedRelationalDatabaseValues>,
#[serde(rename = "preferredBackupWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_backup_window: Option<String>,
#[serde(rename = "preferredMaintenanceWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_maintenance_window: Option<String>,
#[serde(rename = "publiclyAccessible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publicly_accessible: Option<bool>,
#[serde(rename = "relationalDatabaseBlueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_blueprint_id: Option<String>,
#[serde(rename = "relationalDatabaseBundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_bundle_id: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "secondaryAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secondary_availability_zone: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabaseBlueprint {
#[serde(rename = "blueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blueprint_id: Option<String>,
#[serde(rename = "engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "engineDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_description: Option<String>,
#[serde(rename = "engineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "engineVersionDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version_description: Option<String>,
#[serde(rename = "isEngineDefault")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_engine_default: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabaseBundle {
#[serde(rename = "bundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "cpuCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu_count: Option<i64>,
#[serde(rename = "diskSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_size_in_gb: Option<i64>,
#[serde(rename = "isActive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(rename = "isEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_encrypted: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "price")]
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<f32>,
#[serde(rename = "ramSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ram_size_in_gb: Option<f32>,
#[serde(rename = "transferPerMonthInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_per_month_in_gb: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabaseEndpoint {
#[serde(rename = "address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<String>,
#[serde(rename = "port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabaseEvent {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "eventCategories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories: Option<Vec<String>>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabaseHardware {
#[serde(rename = "cpuCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu_count: Option<i64>,
#[serde(rename = "diskSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_size_in_gb: Option<i64>,
#[serde(rename = "ramSizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ram_size_in_gb: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RelationalDatabaseParameter {
#[serde(rename = "allowedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_values: Option<String>,
#[serde(rename = "applyMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apply_method: Option<String>,
#[serde(rename = "applyType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apply_type: Option<String>,
#[serde(rename = "dataType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_type: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "isModifiable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_modifiable: Option<bool>,
#[serde(rename = "parameterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_name: Option<String>,
#[serde(rename = "parameterValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelationalDatabaseSnapshot {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "engineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "fromRelationalDatabaseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_relational_database_arn: Option<String>,
#[serde(rename = "fromRelationalDatabaseBlueprintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_relational_database_blueprint_id: Option<String>,
#[serde(rename = "fromRelationalDatabaseBundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_relational_database_bundle_id: Option<String>,
#[serde(rename = "fromRelationalDatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_relational_database_name: Option<String>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "sizeInGb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size_in_gb: Option<i64>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
#[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 ReleaseStaticIpRequest {
#[serde(rename = "staticIpName")]
pub static_ip_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReleaseStaticIpResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RenewalSummary {
#[serde(rename = "domainValidationRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_validation_records: Option<Vec<DomainValidationRecord>>,
#[serde(rename = "renewalStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_status: Option<String>,
#[serde(rename = "renewalStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_status_reason: Option<String>,
#[serde(rename = "updatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResetDistributionCacheRequest {
#[serde(rename = "distributionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResetDistributionCacheResult {
#[serde(rename = "createTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
#[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 ResourceLocation {
#[serde(rename = "availabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "regionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceRecord {
#[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 = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SendContactMethodVerificationRequest {
#[serde(rename = "protocol")]
pub protocol: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SendContactMethodVerificationResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartInstanceRequest {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartInstanceResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartRelationalDatabaseRequest {
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartRelationalDatabaseResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StaticIp {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "attachedTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_to: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "ipAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "isAttached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_attached: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<ResourceLocation>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "supportCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_code: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopInstanceRequest {
#[serde(rename = "force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopInstanceResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopRelationalDatabaseRequest {
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "relationalDatabaseSnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_snapshot_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopRelationalDatabaseResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "resourceName")]
pub resource_name: 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 TagResourceResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TestAlarmRequest {
#[serde(rename = "alarmName")]
pub alarm_name: String,
#[serde(rename = "state")]
pub state: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TestAlarmResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnpeerVpcRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnpeerVpcResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "resourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "resourceName")]
pub resource_name: 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 UntagResourceResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateContainerServiceRequest {
#[serde(rename = "isDisabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_disabled: Option<bool>,
#[serde(rename = "power")]
#[serde(skip_serializing_if = "Option::is_none")]
pub power: Option<String>,
#[serde(rename = "publicDomainNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_domain_names: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "scale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scale: Option<i64>,
#[serde(rename = "serviceName")]
pub service_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateContainerServiceResult {
#[serde(rename = "containerService")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_service: Option<ContainerService>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDistributionBundleRequest {
#[serde(rename = "bundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "distributionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDistributionBundleResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDistributionRequest {
#[serde(rename = "cacheBehaviorSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_behavior_settings: Option<CacheSettings>,
#[serde(rename = "cacheBehaviors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_behaviors: Option<Vec<CacheBehaviorPerPath>>,
#[serde(rename = "defaultCacheBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_cache_behavior: Option<CacheBehavior>,
#[serde(rename = "distributionName")]
pub distribution_name: String,
#[serde(rename = "isEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_enabled: Option<bool>,
#[serde(rename = "origin")]
#[serde(skip_serializing_if = "Option::is_none")]
pub origin: Option<InputOrigin>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDistributionResult {
#[serde(rename = "operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDomainEntryRequest {
#[serde(rename = "domainEntry")]
pub domain_entry: DomainEntry,
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDomainEntryResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLoadBalancerAttributeRequest {
#[serde(rename = "attributeName")]
pub attribute_name: String,
#[serde(rename = "attributeValue")]
pub attribute_value: String,
#[serde(rename = "loadBalancerName")]
pub load_balancer_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateLoadBalancerAttributeResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRelationalDatabaseParametersRequest {
#[serde(rename = "parameters")]
pub parameters: Vec<RelationalDatabaseParameter>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRelationalDatabaseParametersResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRelationalDatabaseRequest {
#[serde(rename = "applyImmediately")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apply_immediately: Option<bool>,
#[serde(rename = "caCertificateIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ca_certificate_identifier: Option<String>,
#[serde(rename = "disableBackupRetention")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_backup_retention: Option<bool>,
#[serde(rename = "enableBackupRetention")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_backup_retention: Option<bool>,
#[serde(rename = "masterUserPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_password: Option<String>,
#[serde(rename = "preferredBackupWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_backup_window: Option<String>,
#[serde(rename = "preferredMaintenanceWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_maintenance_window: Option<String>,
#[serde(rename = "publiclyAccessible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publicly_accessible: Option<bool>,
#[serde(rename = "relationalDatabaseName")]
pub relational_database_name: String,
#[serde(rename = "rotateMasterUserPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rotate_master_user_password: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRelationalDatabaseResult {
#[serde(rename = "operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<Operation>>,
}
#[derive(Debug, PartialEq)]
pub enum AllocateStaticIpError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl AllocateStaticIpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AllocateStaticIpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AllocateStaticIpError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(AllocateStaticIpError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(AllocateStaticIpError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(AllocateStaticIpError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(AllocateStaticIpError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(AllocateStaticIpError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(AllocateStaticIpError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllocateStaticIpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllocateStaticIpError::AccessDenied(ref cause) => write!(f, "{}", cause),
AllocateStaticIpError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
AllocateStaticIpError::InvalidInput(ref cause) => write!(f, "{}", cause),
AllocateStaticIpError::NotFound(ref cause) => write!(f, "{}", cause),
AllocateStaticIpError::OperationFailure(ref cause) => write!(f, "{}", cause),
AllocateStaticIpError::Service(ref cause) => write!(f, "{}", cause),
AllocateStaticIpError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AllocateStaticIpError {}
#[derive(Debug, PartialEq)]
pub enum AttachCertificateToDistributionError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl AttachCertificateToDistributionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AttachCertificateToDistributionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
AttachCertificateToDistributionError::AccessDenied(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
AttachCertificateToDistributionError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(AttachCertificateToDistributionError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
AttachCertificateToDistributionError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(AttachCertificateToDistributionError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
AttachCertificateToDistributionError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachCertificateToDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachCertificateToDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachCertificateToDistributionError::InvalidInput(ref cause) => write!(f, "{}", cause),
AttachCertificateToDistributionError::NotFound(ref cause) => write!(f, "{}", cause),
AttachCertificateToDistributionError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
AttachCertificateToDistributionError::Service(ref cause) => write!(f, "{}", cause),
AttachCertificateToDistributionError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AttachCertificateToDistributionError {}
#[derive(Debug, PartialEq)]
pub enum AttachDiskError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl AttachDiskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachDiskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachDiskError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(AttachDiskError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(AttachDiskError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(AttachDiskError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(AttachDiskError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(AttachDiskError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(AttachDiskError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachDiskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachDiskError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachDiskError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
AttachDiskError::InvalidInput(ref cause) => write!(f, "{}", cause),
AttachDiskError::NotFound(ref cause) => write!(f, "{}", cause),
AttachDiskError::OperationFailure(ref cause) => write!(f, "{}", cause),
AttachDiskError::Service(ref cause) => write!(f, "{}", cause),
AttachDiskError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachDiskError {}
#[derive(Debug, PartialEq)]
pub enum AttachInstancesToLoadBalancerError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl AttachInstancesToLoadBalancerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AttachInstancesToLoadBalancerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachInstancesToLoadBalancerError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
AttachInstancesToLoadBalancerError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(AttachInstancesToLoadBalancerError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(AttachInstancesToLoadBalancerError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
AttachInstancesToLoadBalancerError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(AttachInstancesToLoadBalancerError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
AttachInstancesToLoadBalancerError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachInstancesToLoadBalancerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachInstancesToLoadBalancerError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachInstancesToLoadBalancerError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
AttachInstancesToLoadBalancerError::InvalidInput(ref cause) => write!(f, "{}", cause),
AttachInstancesToLoadBalancerError::NotFound(ref cause) => write!(f, "{}", cause),
AttachInstancesToLoadBalancerError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
AttachInstancesToLoadBalancerError::Service(ref cause) => write!(f, "{}", cause),
AttachInstancesToLoadBalancerError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AttachInstancesToLoadBalancerError {}
#[derive(Debug, PartialEq)]
pub enum AttachLoadBalancerTlsCertificateError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl AttachLoadBalancerTlsCertificateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AttachLoadBalancerTlsCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
AttachLoadBalancerTlsCertificateError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
AttachLoadBalancerTlsCertificateError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
AttachLoadBalancerTlsCertificateError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(AttachLoadBalancerTlsCertificateError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
AttachLoadBalancerTlsCertificateError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(AttachLoadBalancerTlsCertificateError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
AttachLoadBalancerTlsCertificateError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachLoadBalancerTlsCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachLoadBalancerTlsCertificateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
AttachLoadBalancerTlsCertificateError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
AttachLoadBalancerTlsCertificateError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
AttachLoadBalancerTlsCertificateError::NotFound(ref cause) => write!(f, "{}", cause),
AttachLoadBalancerTlsCertificateError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
AttachLoadBalancerTlsCertificateError::Service(ref cause) => write!(f, "{}", cause),
AttachLoadBalancerTlsCertificateError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AttachLoadBalancerTlsCertificateError {}
#[derive(Debug, PartialEq)]
pub enum AttachStaticIpError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl AttachStaticIpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachStaticIpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachStaticIpError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(AttachStaticIpError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(AttachStaticIpError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(AttachStaticIpError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(AttachStaticIpError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(AttachStaticIpError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(AttachStaticIpError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachStaticIpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachStaticIpError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachStaticIpError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
AttachStaticIpError::InvalidInput(ref cause) => write!(f, "{}", cause),
AttachStaticIpError::NotFound(ref cause) => write!(f, "{}", cause),
AttachStaticIpError::OperationFailure(ref cause) => write!(f, "{}", cause),
AttachStaticIpError::Service(ref cause) => write!(f, "{}", cause),
AttachStaticIpError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachStaticIpError {}
#[derive(Debug, PartialEq)]
pub enum CloseInstancePublicPortsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CloseInstancePublicPortsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CloseInstancePublicPortsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CloseInstancePublicPortsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CloseInstancePublicPortsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CloseInstancePublicPortsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CloseInstancePublicPortsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CloseInstancePublicPortsError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CloseInstancePublicPortsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CloseInstancePublicPortsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CloseInstancePublicPortsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CloseInstancePublicPortsError::AccessDenied(ref cause) => write!(f, "{}", cause),
CloseInstancePublicPortsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CloseInstancePublicPortsError::InvalidInput(ref cause) => write!(f, "{}", cause),
CloseInstancePublicPortsError::NotFound(ref cause) => write!(f, "{}", cause),
CloseInstancePublicPortsError::OperationFailure(ref cause) => write!(f, "{}", cause),
CloseInstancePublicPortsError::Service(ref cause) => write!(f, "{}", cause),
CloseInstancePublicPortsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CloseInstancePublicPortsError {}
#[derive(Debug, PartialEq)]
pub enum CopySnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CopySnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopySnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CopySnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CopySnapshotError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CopySnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CopySnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CopySnapshotError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CopySnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CopySnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CopySnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CopySnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
CopySnapshotError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CopySnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
CopySnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
CopySnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
CopySnapshotError::Service(ref cause) => write!(f, "{}", cause),
CopySnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CopySnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateCertificateError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl CreateCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateCertificateError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CreateCertificateError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateCertificateError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateCertificateError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateCertificateError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCertificateError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateCertificateError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateCertificateError::NotFound(ref cause) => write!(f, "{}", cause),
CreateCertificateError::Service(ref cause) => write!(f, "{}", cause),
CreateCertificateError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCertificateError {}
#[derive(Debug, PartialEq)]
pub enum CreateCloudFormationStackError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateCloudFormationStackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCloudFormationStackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateCloudFormationStackError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateCloudFormationStackError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CreateCloudFormationStackError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateCloudFormationStackError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateCloudFormationStackError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateCloudFormationStackError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateCloudFormationStackError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCloudFormationStackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCloudFormationStackError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateCloudFormationStackError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateCloudFormationStackError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateCloudFormationStackError::NotFound(ref cause) => write!(f, "{}", cause),
CreateCloudFormationStackError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateCloudFormationStackError::Service(ref cause) => write!(f, "{}", cause),
CreateCloudFormationStackError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCloudFormationStackError {}
#[derive(Debug, PartialEq)]
pub enum CreateContactMethodError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateContactMethodError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateContactMethodError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateContactMethodError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CreateContactMethodError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateContactMethodError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateContactMethodError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateContactMethodError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateContactMethodError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateContactMethodError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateContactMethodError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateContactMethodError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateContactMethodError::NotFound(ref cause) => write!(f, "{}", cause),
CreateContactMethodError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateContactMethodError::Service(ref cause) => write!(f, "{}", cause),
CreateContactMethodError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateContactMethodError {}
#[derive(Debug, PartialEq)]
pub enum CreateContainerServiceError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl CreateContainerServiceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateContainerServiceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateContainerServiceError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CreateContainerServiceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateContainerServiceError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateContainerServiceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateContainerServiceError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateContainerServiceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateContainerServiceError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateContainerServiceError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateContainerServiceError::NotFound(ref cause) => write!(f, "{}", cause),
CreateContainerServiceError::Service(ref cause) => write!(f, "{}", cause),
CreateContainerServiceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateContainerServiceError {}
#[derive(Debug, PartialEq)]
pub enum CreateContainerServiceDeploymentError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl CreateContainerServiceDeploymentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateContainerServiceDeploymentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
CreateContainerServiceDeploymentError::AccessDenied(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
CreateContainerServiceDeploymentError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(CreateContainerServiceDeploymentError::NotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateContainerServiceDeploymentError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
CreateContainerServiceDeploymentError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateContainerServiceDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateContainerServiceDeploymentError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateContainerServiceDeploymentError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
CreateContainerServiceDeploymentError::NotFound(ref cause) => write!(f, "{}", cause),
CreateContainerServiceDeploymentError::Service(ref cause) => write!(f, "{}", cause),
CreateContainerServiceDeploymentError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateContainerServiceDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum CreateContainerServiceRegistryLoginError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl CreateContainerServiceRegistryLoginError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateContainerServiceRegistryLoginError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
CreateContainerServiceRegistryLoginError::AccessDenied(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
CreateContainerServiceRegistryLoginError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
CreateContainerServiceRegistryLoginError::NotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateContainerServiceRegistryLoginError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
CreateContainerServiceRegistryLoginError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateContainerServiceRegistryLoginError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateContainerServiceRegistryLoginError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateContainerServiceRegistryLoginError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
CreateContainerServiceRegistryLoginError::NotFound(ref cause) => write!(f, "{}", cause),
CreateContainerServiceRegistryLoginError::Service(ref cause) => write!(f, "{}", cause),
CreateContainerServiceRegistryLoginError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateContainerServiceRegistryLoginError {}
#[derive(Debug, PartialEq)]
pub enum CreateDiskError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateDiskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDiskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDiskError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateDiskError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CreateDiskError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDiskError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateDiskError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateDiskError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateDiskError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDiskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDiskError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDiskError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateDiskError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDiskError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDiskError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateDiskError::Service(ref cause) => write!(f, "{}", cause),
CreateDiskError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDiskError {}
#[derive(Debug, PartialEq)]
pub enum CreateDiskFromSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateDiskFromSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDiskFromSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDiskFromSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateDiskFromSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CreateDiskFromSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDiskFromSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateDiskFromSnapshotError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateDiskFromSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateDiskFromSnapshotError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDiskFromSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDiskFromSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDiskFromSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateDiskFromSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDiskFromSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDiskFromSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateDiskFromSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateDiskFromSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDiskFromSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateDiskSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateDiskSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDiskSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDiskSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateDiskSnapshotError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(CreateDiskSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDiskSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateDiskSnapshotError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateDiskSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateDiskSnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDiskSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDiskSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDiskSnapshotError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateDiskSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDiskSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDiskSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateDiskSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateDiskSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDiskSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateDistributionError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDistributionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDistributionError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CreateDistributionError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDistributionError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateDistributionError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateDistributionError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateDistributionError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDistributionError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDistributionError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateDistributionError::Service(ref cause) => write!(f, "{}", cause),
CreateDistributionError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDistributionError {}
#[derive(Debug, PartialEq)]
pub enum CreateDomainError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDomainError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateDomainError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(CreateDomainError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDomainError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateDomainError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateDomainError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateDomainError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDomainError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDomainError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateDomainError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDomainError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDomainError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateDomainError::Service(ref cause) => write!(f, "{}", cause),
CreateDomainError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDomainError {}
#[derive(Debug, PartialEq)]
pub enum CreateDomainEntryError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateDomainEntryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDomainEntryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDomainEntryError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateDomainEntryError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(CreateDomainEntryError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDomainEntryError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateDomainEntryError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateDomainEntryError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateDomainEntryError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDomainEntryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDomainEntryError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDomainEntryError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateDomainEntryError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDomainEntryError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDomainEntryError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateDomainEntryError::Service(ref cause) => write!(f, "{}", cause),
CreateDomainEntryError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDomainEntryError {}
#[derive(Debug, PartialEq)]
pub enum CreateInstanceSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateInstanceSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInstanceSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateInstanceSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateInstanceSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CreateInstanceSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateInstanceSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateInstanceSnapshotError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateInstanceSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateInstanceSnapshotError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateInstanceSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInstanceSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateInstanceSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateInstanceSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateInstanceSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
CreateInstanceSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateInstanceSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateInstanceSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateInstanceSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateInstancesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateInstancesError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateInstancesError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(CreateInstancesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateInstancesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateInstancesError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateInstancesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateInstancesError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInstancesError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateInstancesError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateInstancesError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateInstancesError::NotFound(ref cause) => write!(f, "{}", cause),
CreateInstancesError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateInstancesError::Service(ref cause) => write!(f, "{}", cause),
CreateInstancesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateInstancesError {}
#[derive(Debug, PartialEq)]
pub enum CreateInstancesFromSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateInstancesFromSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateInstancesFromSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateInstancesFromSnapshotError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateInstancesFromSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CreateInstancesFromSnapshotError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateInstancesFromSnapshotError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
CreateInstancesFromSnapshotError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateInstancesFromSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateInstancesFromSnapshotError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateInstancesFromSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInstancesFromSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateInstancesFromSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateInstancesFromSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateInstancesFromSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
CreateInstancesFromSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateInstancesFromSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateInstancesFromSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateInstancesFromSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateKeyPairError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateKeyPairError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateKeyPairError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateKeyPairError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(CreateKeyPairError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateKeyPairError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateKeyPairError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateKeyPairError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateKeyPairError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateKeyPairError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateKeyPairError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateKeyPairError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateKeyPairError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateKeyPairError::NotFound(ref cause) => write!(f, "{}", cause),
CreateKeyPairError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateKeyPairError::Service(ref cause) => write!(f, "{}", cause),
CreateKeyPairError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateKeyPairError {}
#[derive(Debug, PartialEq)]
pub enum CreateLoadBalancerError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateLoadBalancerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLoadBalancerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateLoadBalancerError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(CreateLoadBalancerError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(CreateLoadBalancerError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateLoadBalancerError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateLoadBalancerError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateLoadBalancerError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateLoadBalancerError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLoadBalancerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLoadBalancerError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerError::NotFound(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerError::Service(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLoadBalancerError {}
#[derive(Debug, PartialEq)]
pub enum CreateLoadBalancerTlsCertificateError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateLoadBalancerTlsCertificateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateLoadBalancerTlsCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
CreateLoadBalancerTlsCertificateError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateLoadBalancerTlsCertificateError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
CreateLoadBalancerTlsCertificateError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(CreateLoadBalancerTlsCertificateError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
CreateLoadBalancerTlsCertificateError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateLoadBalancerTlsCertificateError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
CreateLoadBalancerTlsCertificateError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLoadBalancerTlsCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLoadBalancerTlsCertificateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateLoadBalancerTlsCertificateError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateLoadBalancerTlsCertificateError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
CreateLoadBalancerTlsCertificateError::NotFound(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerTlsCertificateError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
CreateLoadBalancerTlsCertificateError::Service(ref cause) => write!(f, "{}", cause),
CreateLoadBalancerTlsCertificateError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateLoadBalancerTlsCertificateError {}
#[derive(Debug, PartialEq)]
pub enum CreateRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateRelationalDatabaseError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CreateRelationalDatabaseError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(CreateRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(CreateRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum CreateRelationalDatabaseFromSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateRelationalDatabaseFromSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateRelationalDatabaseFromSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::NotFound(err.msg),
)
}
"OperationFailureException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::Service(err.msg),
)
}
"UnauthenticatedException" => {
return RusotoError::Service(
CreateRelationalDatabaseFromSnapshotError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRelationalDatabaseFromSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRelationalDatabaseFromSnapshotError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseFromSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseFromSnapshotError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseFromSnapshotError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseFromSnapshotError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseFromSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseFromSnapshotError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateRelationalDatabaseFromSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateRelationalDatabaseSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl CreateRelationalDatabaseSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateRelationalDatabaseSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
CreateRelationalDatabaseSnapshotError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
CreateRelationalDatabaseSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
CreateRelationalDatabaseSnapshotError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(CreateRelationalDatabaseSnapshotError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
CreateRelationalDatabaseSnapshotError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateRelationalDatabaseSnapshotError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
CreateRelationalDatabaseSnapshotError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRelationalDatabaseSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRelationalDatabaseSnapshotError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseSnapshotError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseSnapshotError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
CreateRelationalDatabaseSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateRelationalDatabaseSnapshotError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateRelationalDatabaseSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAlarmError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteAlarmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAlarmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteAlarmError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteAlarmError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteAlarmError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteAlarmError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteAlarmError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteAlarmError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAlarmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAlarmError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteAlarmError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteAlarmError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteAlarmError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteAlarmError::Service(ref cause) => write!(f, "{}", cause),
DeleteAlarmError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAlarmError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAutoSnapshotError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteAutoSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAutoSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteAutoSnapshotError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteAutoSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteAutoSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteAutoSnapshotError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteAutoSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteAutoSnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAutoSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAutoSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteAutoSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteAutoSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteAutoSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteAutoSnapshotError::Service(ref cause) => write!(f, "{}", cause),
DeleteAutoSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAutoSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCertificateError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl DeleteCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteCertificateError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteCertificateError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteCertificateError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteCertificateError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteCertificateError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCertificateError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteCertificateError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteCertificateError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteCertificateError::Service(ref cause) => write!(f, "{}", cause),
DeleteCertificateError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCertificateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteContactMethodError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteContactMethodError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContactMethodError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteContactMethodError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteContactMethodError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteContactMethodError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteContactMethodError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteContactMethodError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteContactMethodError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteContactMethodError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteContactMethodError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteContactMethodError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteContactMethodError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteContactMethodError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteContactMethodError::Service(ref cause) => write!(f, "{}", cause),
DeleteContactMethodError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteContactMethodError {}
#[derive(Debug, PartialEq)]
pub enum DeleteContainerImageError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl DeleteContainerImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContainerImageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteContainerImageError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteContainerImageError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteContainerImageError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteContainerImageError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteContainerImageError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteContainerImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteContainerImageError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteContainerImageError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteContainerImageError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteContainerImageError::Service(ref cause) => write!(f, "{}", cause),
DeleteContainerImageError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteContainerImageError {}
#[derive(Debug, PartialEq)]
pub enum DeleteContainerServiceError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl DeleteContainerServiceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContainerServiceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteContainerServiceError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteContainerServiceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteContainerServiceError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteContainerServiceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteContainerServiceError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteContainerServiceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteContainerServiceError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteContainerServiceError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteContainerServiceError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteContainerServiceError::Service(ref cause) => write!(f, "{}", cause),
DeleteContainerServiceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteContainerServiceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDiskError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteDiskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDiskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDiskError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteDiskError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteDiskError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDiskError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteDiskError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteDiskError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteDiskError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDiskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDiskError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDiskError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteDiskError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDiskError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDiskError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteDiskError::Service(ref cause) => write!(f, "{}", cause),
DeleteDiskError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDiskError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDiskSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteDiskSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDiskSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDiskSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteDiskSnapshotError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteDiskSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDiskSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteDiskSnapshotError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteDiskSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteDiskSnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDiskSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDiskSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDiskSnapshotError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteDiskSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDiskSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDiskSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteDiskSnapshotError::Service(ref cause) => write!(f, "{}", cause),
DeleteDiskSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDiskSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDistributionError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDistributionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDistributionError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteDistributionError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDistributionError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteDistributionError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteDistributionError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteDistributionError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::Service(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDistributionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDomainError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDomainError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteDomainError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteDomainError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDomainError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteDomainError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteDomainError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteDomainError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDomainError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDomainError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteDomainError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDomainError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDomainError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteDomainError::Service(ref cause) => write!(f, "{}", cause),
DeleteDomainError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDomainError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDomainEntryError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteDomainEntryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDomainEntryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDomainEntryError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteDomainEntryError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteDomainEntryError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDomainEntryError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteDomainEntryError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteDomainEntryError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteDomainEntryError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDomainEntryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDomainEntryError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDomainEntryError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteDomainEntryError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteDomainEntryError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDomainEntryError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteDomainEntryError::Service(ref cause) => write!(f, "{}", cause),
DeleteDomainEntryError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDomainEntryError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInstanceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteInstanceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteInstanceError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteInstanceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteInstanceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteInstanceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteInstanceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteInstanceError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInstanceError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteInstanceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteInstanceError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteInstanceError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteInstanceError::Service(ref cause) => write!(f, "{}", cause),
DeleteInstanceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteInstanceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInstanceSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteInstanceSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInstanceSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteInstanceSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
DeleteInstanceSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DeleteInstanceSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteInstanceSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteInstanceSnapshotError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteInstanceSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteInstanceSnapshotError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInstanceSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInstanceSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteInstanceSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
DeleteInstanceSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteInstanceSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteInstanceSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteInstanceSnapshotError::Service(ref cause) => write!(f, "{}", cause),
DeleteInstanceSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteInstanceSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteKeyPairError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteKeyPairError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteKeyPairError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteKeyPairError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteKeyPairError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteKeyPairError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteKeyPairError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteKeyPairError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteKeyPairError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteKeyPairError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteKeyPairError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteKeyPairError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteKeyPairError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteKeyPairError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteKeyPairError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteKeyPairError::Service(ref cause) => write!(f, "{}", cause),
DeleteKeyPairError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteKeyPairError {}
#[derive(Debug, PartialEq)]
pub enum DeleteKnownHostKeysError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteKnownHostKeysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteKnownHostKeysError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteKnownHostKeysError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteKnownHostKeysError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteKnownHostKeysError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteKnownHostKeysError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteKnownHostKeysError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteKnownHostKeysError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteKnownHostKeysError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteKnownHostKeysError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteKnownHostKeysError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteKnownHostKeysError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteKnownHostKeysError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteKnownHostKeysError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteKnownHostKeysError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteKnownHostKeysError::Service(ref cause) => write!(f, "{}", cause),
DeleteKnownHostKeysError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteKnownHostKeysError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLoadBalancerError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteLoadBalancerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLoadBalancerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteLoadBalancerError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DeleteLoadBalancerError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DeleteLoadBalancerError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteLoadBalancerError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteLoadBalancerError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteLoadBalancerError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteLoadBalancerError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLoadBalancerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLoadBalancerError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerError::Service(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLoadBalancerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLoadBalancerTlsCertificateError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteLoadBalancerTlsCertificateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteLoadBalancerTlsCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
DeleteLoadBalancerTlsCertificateError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
DeleteLoadBalancerTlsCertificateError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
DeleteLoadBalancerTlsCertificateError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DeleteLoadBalancerTlsCertificateError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
DeleteLoadBalancerTlsCertificateError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteLoadBalancerTlsCertificateError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
DeleteLoadBalancerTlsCertificateError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLoadBalancerTlsCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLoadBalancerTlsCertificateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteLoadBalancerTlsCertificateError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
DeleteLoadBalancerTlsCertificateError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
DeleteLoadBalancerTlsCertificateError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerTlsCertificateError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
DeleteLoadBalancerTlsCertificateError::Service(ref cause) => write!(f, "{}", cause),
DeleteLoadBalancerTlsCertificateError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteLoadBalancerTlsCertificateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteRelationalDatabaseError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
DeleteRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DeleteRelationalDatabaseError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DeleteRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DeleteRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
DeleteRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRelationalDatabaseSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DeleteRelationalDatabaseSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteRelationalDatabaseSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
DeleteRelationalDatabaseSnapshotError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
DeleteRelationalDatabaseSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
DeleteRelationalDatabaseSnapshotError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DeleteRelationalDatabaseSnapshotError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
DeleteRelationalDatabaseSnapshotError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteRelationalDatabaseSnapshotError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
DeleteRelationalDatabaseSnapshotError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRelationalDatabaseSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRelationalDatabaseSnapshotError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteRelationalDatabaseSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
DeleteRelationalDatabaseSnapshotError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
DeleteRelationalDatabaseSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseSnapshotError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
DeleteRelationalDatabaseSnapshotError::Service(ref cause) => write!(f, "{}", cause),
DeleteRelationalDatabaseSnapshotError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteRelationalDatabaseSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DetachCertificateFromDistributionError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DetachCertificateFromDistributionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DetachCertificateFromDistributionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
DetachCertificateFromDistributionError::AccessDenied(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
DetachCertificateFromDistributionError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DetachCertificateFromDistributionError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
DetachCertificateFromDistributionError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DetachCertificateFromDistributionError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
DetachCertificateFromDistributionError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachCertificateFromDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachCertificateFromDistributionError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DetachCertificateFromDistributionError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
DetachCertificateFromDistributionError::NotFound(ref cause) => write!(f, "{}", cause),
DetachCertificateFromDistributionError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
DetachCertificateFromDistributionError::Service(ref cause) => write!(f, "{}", cause),
DetachCertificateFromDistributionError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DetachCertificateFromDistributionError {}
#[derive(Debug, PartialEq)]
pub enum DetachDiskError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DetachDiskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachDiskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DetachDiskError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DetachDiskError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DetachDiskError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DetachDiskError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DetachDiskError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DetachDiskError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DetachDiskError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachDiskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachDiskError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachDiskError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DetachDiskError::InvalidInput(ref cause) => write!(f, "{}", cause),
DetachDiskError::NotFound(ref cause) => write!(f, "{}", cause),
DetachDiskError::OperationFailure(ref cause) => write!(f, "{}", cause),
DetachDiskError::Service(ref cause) => write!(f, "{}", cause),
DetachDiskError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachDiskError {}
#[derive(Debug, PartialEq)]
pub enum DetachInstancesFromLoadBalancerError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DetachInstancesFromLoadBalancerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DetachInstancesFromLoadBalancerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
DetachInstancesFromLoadBalancerError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
DetachInstancesFromLoadBalancerError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
DetachInstancesFromLoadBalancerError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DetachInstancesFromLoadBalancerError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
DetachInstancesFromLoadBalancerError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DetachInstancesFromLoadBalancerError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
DetachInstancesFromLoadBalancerError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachInstancesFromLoadBalancerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachInstancesFromLoadBalancerError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachInstancesFromLoadBalancerError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
DetachInstancesFromLoadBalancerError::InvalidInput(ref cause) => write!(f, "{}", cause),
DetachInstancesFromLoadBalancerError::NotFound(ref cause) => write!(f, "{}", cause),
DetachInstancesFromLoadBalancerError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
DetachInstancesFromLoadBalancerError::Service(ref cause) => write!(f, "{}", cause),
DetachInstancesFromLoadBalancerError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DetachInstancesFromLoadBalancerError {}
#[derive(Debug, PartialEq)]
pub enum DetachStaticIpError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DetachStaticIpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachStaticIpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DetachStaticIpError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(DetachStaticIpError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DetachStaticIpError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DetachStaticIpError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DetachStaticIpError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DetachStaticIpError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DetachStaticIpError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachStaticIpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachStaticIpError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachStaticIpError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
DetachStaticIpError::InvalidInput(ref cause) => write!(f, "{}", cause),
DetachStaticIpError::NotFound(ref cause) => write!(f, "{}", cause),
DetachStaticIpError::OperationFailure(ref cause) => write!(f, "{}", cause),
DetachStaticIpError::Service(ref cause) => write!(f, "{}", cause),
DetachStaticIpError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachStaticIpError {}
#[derive(Debug, PartialEq)]
pub enum DisableAddOnError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DisableAddOnError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableAddOnError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DisableAddOnError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DisableAddOnError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DisableAddOnError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DisableAddOnError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DisableAddOnError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DisableAddOnError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableAddOnError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableAddOnError::AccessDenied(ref cause) => write!(f, "{}", cause),
DisableAddOnError::InvalidInput(ref cause) => write!(f, "{}", cause),
DisableAddOnError::NotFound(ref cause) => write!(f, "{}", cause),
DisableAddOnError::OperationFailure(ref cause) => write!(f, "{}", cause),
DisableAddOnError::Service(ref cause) => write!(f, "{}", cause),
DisableAddOnError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableAddOnError {}
#[derive(Debug, PartialEq)]
pub enum DownloadDefaultKeyPairError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl DownloadDefaultKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DownloadDefaultKeyPairError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DownloadDefaultKeyPairError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
DownloadDefaultKeyPairError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DownloadDefaultKeyPairError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DownloadDefaultKeyPairError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(DownloadDefaultKeyPairError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DownloadDefaultKeyPairError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(DownloadDefaultKeyPairError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DownloadDefaultKeyPairError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DownloadDefaultKeyPairError::AccessDenied(ref cause) => write!(f, "{}", cause),
DownloadDefaultKeyPairError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
DownloadDefaultKeyPairError::InvalidInput(ref cause) => write!(f, "{}", cause),
DownloadDefaultKeyPairError::NotFound(ref cause) => write!(f, "{}", cause),
DownloadDefaultKeyPairError::OperationFailure(ref cause) => write!(f, "{}", cause),
DownloadDefaultKeyPairError::Service(ref cause) => write!(f, "{}", cause),
DownloadDefaultKeyPairError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DownloadDefaultKeyPairError {}
#[derive(Debug, PartialEq)]
pub enum EnableAddOnError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl EnableAddOnError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableAddOnError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(EnableAddOnError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(EnableAddOnError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(EnableAddOnError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(EnableAddOnError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(EnableAddOnError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(EnableAddOnError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableAddOnError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableAddOnError::AccessDenied(ref cause) => write!(f, "{}", cause),
EnableAddOnError::InvalidInput(ref cause) => write!(f, "{}", cause),
EnableAddOnError::NotFound(ref cause) => write!(f, "{}", cause),
EnableAddOnError::OperationFailure(ref cause) => write!(f, "{}", cause),
EnableAddOnError::Service(ref cause) => write!(f, "{}", cause),
EnableAddOnError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableAddOnError {}
#[derive(Debug, PartialEq)]
pub enum ExportSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl ExportSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ExportSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ExportSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(ExportSnapshotError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ExportSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ExportSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(ExportSnapshotError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ExportSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(ExportSnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExportSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExportSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
ExportSnapshotError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
ExportSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
ExportSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
ExportSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
ExportSnapshotError::Service(ref cause) => write!(f, "{}", cause),
ExportSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExportSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum GetActiveNamesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetActiveNamesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetActiveNamesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetActiveNamesError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetActiveNamesError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetActiveNamesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetActiveNamesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetActiveNamesError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetActiveNamesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetActiveNamesError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetActiveNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetActiveNamesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetActiveNamesError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetActiveNamesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetActiveNamesError::NotFound(ref cause) => write!(f, "{}", cause),
GetActiveNamesError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetActiveNamesError::Service(ref cause) => write!(f, "{}", cause),
GetActiveNamesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetActiveNamesError {}
#[derive(Debug, PartialEq)]
pub enum GetAlarmsError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetAlarmsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAlarmsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetAlarmsError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetAlarmsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetAlarmsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetAlarmsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetAlarmsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetAlarmsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAlarmsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAlarmsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetAlarmsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetAlarmsError::NotFound(ref cause) => write!(f, "{}", cause),
GetAlarmsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetAlarmsError::Service(ref cause) => write!(f, "{}", cause),
GetAlarmsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAlarmsError {}
#[derive(Debug, PartialEq)]
pub enum GetAutoSnapshotsError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetAutoSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAutoSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetAutoSnapshotsError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetAutoSnapshotsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetAutoSnapshotsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetAutoSnapshotsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetAutoSnapshotsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetAutoSnapshotsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAutoSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAutoSnapshotsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetAutoSnapshotsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetAutoSnapshotsError::NotFound(ref cause) => write!(f, "{}", cause),
GetAutoSnapshotsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetAutoSnapshotsError::Service(ref cause) => write!(f, "{}", cause),
GetAutoSnapshotsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAutoSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum GetBlueprintsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetBlueprintsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBlueprintsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetBlueprintsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetBlueprintsError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetBlueprintsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetBlueprintsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetBlueprintsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetBlueprintsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetBlueprintsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBlueprintsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBlueprintsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetBlueprintsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetBlueprintsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetBlueprintsError::NotFound(ref cause) => write!(f, "{}", cause),
GetBlueprintsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetBlueprintsError::Service(ref cause) => write!(f, "{}", cause),
GetBlueprintsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBlueprintsError {}
#[derive(Debug, PartialEq)]
pub enum GetBundlesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetBundlesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBundlesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetBundlesError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetBundlesError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetBundlesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetBundlesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetBundlesError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetBundlesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetBundlesError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBundlesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBundlesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetBundlesError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetBundlesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetBundlesError::NotFound(ref cause) => write!(f, "{}", cause),
GetBundlesError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetBundlesError::Service(ref cause) => write!(f, "{}", cause),
GetBundlesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBundlesError {}
#[derive(Debug, PartialEq)]
pub enum GetCertificatesError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetCertificatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCertificatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetCertificatesError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetCertificatesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetCertificatesError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetCertificatesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetCertificatesError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCertificatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCertificatesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetCertificatesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetCertificatesError::NotFound(ref cause) => write!(f, "{}", cause),
GetCertificatesError::Service(ref cause) => write!(f, "{}", cause),
GetCertificatesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCertificatesError {}
#[derive(Debug, PartialEq)]
pub enum GetCloudFormationStackRecordsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetCloudFormationStackRecordsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetCloudFormationStackRecordsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetCloudFormationStackRecordsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetCloudFormationStackRecordsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetCloudFormationStackRecordsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetCloudFormationStackRecordsError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetCloudFormationStackRecordsError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetCloudFormationStackRecordsError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetCloudFormationStackRecordsError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCloudFormationStackRecordsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCloudFormationStackRecordsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetCloudFormationStackRecordsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetCloudFormationStackRecordsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetCloudFormationStackRecordsError::NotFound(ref cause) => write!(f, "{}", cause),
GetCloudFormationStackRecordsError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetCloudFormationStackRecordsError::Service(ref cause) => write!(f, "{}", cause),
GetCloudFormationStackRecordsError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetCloudFormationStackRecordsError {}
#[derive(Debug, PartialEq)]
pub enum GetContactMethodsError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetContactMethodsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContactMethodsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContactMethodsError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetContactMethodsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetContactMethodsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetContactMethodsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetContactMethodsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetContactMethodsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContactMethodsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContactMethodsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContactMethodsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContactMethodsError::NotFound(ref cause) => write!(f, "{}", cause),
GetContactMethodsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetContactMethodsError::Service(ref cause) => write!(f, "{}", cause),
GetContactMethodsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContactMethodsError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerAPIMetadataError {
AccessDenied(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerAPIMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerAPIMetadataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerAPIMetadataError::AccessDenied(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetContainerAPIMetadataError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetContainerAPIMetadataError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerAPIMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerAPIMetadataError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerAPIMetadataError::Service(ref cause) => write!(f, "{}", cause),
GetContainerAPIMetadataError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerAPIMetadataError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerImagesError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerImagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerImagesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerImagesError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetContainerImagesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetContainerImagesError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetContainerImagesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetContainerImagesError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerImagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerImagesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerImagesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContainerImagesError::NotFound(ref cause) => write!(f, "{}", cause),
GetContainerImagesError::Service(ref cause) => write!(f, "{}", cause),
GetContainerImagesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerImagesError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerLogError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerLogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerLogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerLogError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetContainerLogError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetContainerLogError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetContainerLogError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetContainerLogError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerLogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerLogError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerLogError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContainerLogError::NotFound(ref cause) => write!(f, "{}", cause),
GetContainerLogError::Service(ref cause) => write!(f, "{}", cause),
GetContainerLogError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerLogError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerServiceDeploymentsError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerServiceDeploymentsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetContainerServiceDeploymentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerServiceDeploymentsError::AccessDenied(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetContainerServiceDeploymentsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetContainerServiceDeploymentsError::NotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetContainerServiceDeploymentsError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetContainerServiceDeploymentsError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerServiceDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerServiceDeploymentsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerServiceDeploymentsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContainerServiceDeploymentsError::NotFound(ref cause) => write!(f, "{}", cause),
GetContainerServiceDeploymentsError::Service(ref cause) => write!(f, "{}", cause),
GetContainerServiceDeploymentsError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetContainerServiceDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerServiceMetricDataError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerServiceMetricDataError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetContainerServiceMetricDataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerServiceMetricDataError::AccessDenied(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetContainerServiceMetricDataError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetContainerServiceMetricDataError::NotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetContainerServiceMetricDataError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetContainerServiceMetricDataError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerServiceMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerServiceMetricDataError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerServiceMetricDataError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContainerServiceMetricDataError::NotFound(ref cause) => write!(f, "{}", cause),
GetContainerServiceMetricDataError::Service(ref cause) => write!(f, "{}", cause),
GetContainerServiceMetricDataError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetContainerServiceMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerServicePowersError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerServicePowersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerServicePowersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerServicePowersError::AccessDenied(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetContainerServicePowersError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetContainerServicePowersError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetContainerServicePowersError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetContainerServicePowersError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerServicePowersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerServicePowersError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerServicePowersError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContainerServicePowersError::NotFound(ref cause) => write!(f, "{}", cause),
GetContainerServicePowersError::Service(ref cause) => write!(f, "{}", cause),
GetContainerServicePowersError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerServicePowersError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerServicesError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl GetContainerServicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerServicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetContainerServicesError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetContainerServicesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetContainerServicesError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetContainerServicesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetContainerServicesError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerServicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerServicesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetContainerServicesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetContainerServicesError::NotFound(ref cause) => write!(f, "{}", cause),
GetContainerServicesError::Service(ref cause) => write!(f, "{}", cause),
GetContainerServicesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerServicesError {}
#[derive(Debug, PartialEq)]
pub enum GetDiskError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDiskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDiskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDiskError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetDiskError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDiskError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDiskError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDiskError::OperationFailure(err.msg))
}
"ServiceException" => return RusotoError::Service(GetDiskError::Service(err.msg)),
"UnauthenticatedException" => {
return RusotoError::Service(GetDiskError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDiskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDiskError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDiskError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetDiskError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDiskError::NotFound(ref cause) => write!(f, "{}", cause),
GetDiskError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDiskError::Service(ref cause) => write!(f, "{}", cause),
GetDiskError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDiskError {}
#[derive(Debug, PartialEq)]
pub enum GetDiskSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDiskSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDiskSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDiskSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetDiskSnapshotError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetDiskSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDiskSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDiskSnapshotError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetDiskSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDiskSnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDiskSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDiskSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotError::Service(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDiskSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum GetDiskSnapshotsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDiskSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDiskSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDiskSnapshotsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetDiskSnapshotsError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetDiskSnapshotsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDiskSnapshotsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDiskSnapshotsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetDiskSnapshotsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDiskSnapshotsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDiskSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDiskSnapshotsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotsError::NotFound(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotsError::Service(ref cause) => write!(f, "{}", cause),
GetDiskSnapshotsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDiskSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum GetDisksError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDisksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDisksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDisksError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetDisksError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDisksError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDisksError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDisksError::OperationFailure(err.msg))
}
"ServiceException" => return RusotoError::Service(GetDisksError::Service(err.msg)),
"UnauthenticatedException" => {
return RusotoError::Service(GetDisksError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDisksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDisksError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDisksError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetDisksError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDisksError::NotFound(ref cause) => write!(f, "{}", cause),
GetDisksError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDisksError::Service(ref cause) => write!(f, "{}", cause),
GetDisksError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDisksError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionBundlesError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDistributionBundlesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDistributionBundlesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDistributionBundlesError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDistributionBundlesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDistributionBundlesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDistributionBundlesError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetDistributionBundlesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDistributionBundlesError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDistributionBundlesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionBundlesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDistributionBundlesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDistributionBundlesError::NotFound(ref cause) => write!(f, "{}", cause),
GetDistributionBundlesError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDistributionBundlesError::Service(ref cause) => write!(f, "{}", cause),
GetDistributionBundlesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDistributionBundlesError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionLatestCacheResetError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDistributionLatestCacheResetError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDistributionLatestCacheResetError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetDistributionLatestCacheResetError::AccessDenied(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
GetDistributionLatestCacheResetError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(GetDistributionLatestCacheResetError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetDistributionLatestCacheResetError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetDistributionLatestCacheResetError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetDistributionLatestCacheResetError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDistributionLatestCacheResetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionLatestCacheResetError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDistributionLatestCacheResetError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDistributionLatestCacheResetError::NotFound(ref cause) => write!(f, "{}", cause),
GetDistributionLatestCacheResetError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetDistributionLatestCacheResetError::Service(ref cause) => write!(f, "{}", cause),
GetDistributionLatestCacheResetError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetDistributionLatestCacheResetError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionMetricDataError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDistributionMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDistributionMetricDataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDistributionMetricDataError::AccessDenied(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetDistributionMetricDataError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetDistributionMetricDataError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDistributionMetricDataError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetDistributionMetricDataError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDistributionMetricDataError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDistributionMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionMetricDataError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDistributionMetricDataError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDistributionMetricDataError::NotFound(ref cause) => write!(f, "{}", cause),
GetDistributionMetricDataError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDistributionMetricDataError::Service(ref cause) => write!(f, "{}", cause),
GetDistributionMetricDataError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDistributionMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionsError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDistributionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDistributionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDistributionsError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDistributionsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDistributionsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDistributionsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetDistributionsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDistributionsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDistributionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDistributionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDistributionsError::NotFound(ref cause) => write!(f, "{}", cause),
GetDistributionsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDistributionsError::Service(ref cause) => write!(f, "{}", cause),
GetDistributionsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDistributionsError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDomainError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetDomainError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDomainError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDomainError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDomainError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetDomainError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDomainError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDomainError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetDomainError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDomainError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDomainError::Service(ref cause) => write!(f, "{}", cause),
GetDomainError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDomainError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetDomainsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDomainsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDomainsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetDomainsError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDomainsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDomainsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetDomainsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetDomainsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetDomainsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDomainsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetDomainsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetDomainsError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetDomainsError::Service(ref cause) => write!(f, "{}", cause),
GetDomainsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDomainsError {}
#[derive(Debug, PartialEq)]
pub enum GetExportSnapshotRecordsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetExportSnapshotRecordsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetExportSnapshotRecordsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetExportSnapshotRecordsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetExportSnapshotRecordsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetExportSnapshotRecordsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetExportSnapshotRecordsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetExportSnapshotRecordsError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetExportSnapshotRecordsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetExportSnapshotRecordsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetExportSnapshotRecordsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetExportSnapshotRecordsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetExportSnapshotRecordsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetExportSnapshotRecordsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetExportSnapshotRecordsError::NotFound(ref cause) => write!(f, "{}", cause),
GetExportSnapshotRecordsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetExportSnapshotRecordsError::Service(ref cause) => write!(f, "{}", cause),
GetExportSnapshotRecordsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetExportSnapshotRecordsError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstanceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetInstanceError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetInstanceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstanceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetInstanceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstanceError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstanceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstanceError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstanceError::Service(ref cause) => write!(f, "{}", cause),
GetInstanceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceAccessDetailsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstanceAccessDetailsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceAccessDetailsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstanceAccessDetailsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetInstanceAccessDetailsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetInstanceAccessDetailsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceAccessDetailsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstanceAccessDetailsError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetInstanceAccessDetailsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstanceAccessDetailsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceAccessDetailsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceAccessDetailsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstanceAccessDetailsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetInstanceAccessDetailsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstanceAccessDetailsError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceAccessDetailsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstanceAccessDetailsError::Service(ref cause) => write!(f, "{}", cause),
GetInstanceAccessDetailsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceAccessDetailsError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceMetricDataError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstanceMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceMetricDataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstanceMetricDataError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetInstanceMetricDataError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetInstanceMetricDataError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceMetricDataError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstanceMetricDataError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetInstanceMetricDataError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstanceMetricDataError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceMetricDataError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstanceMetricDataError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstanceMetricDataError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstanceMetricDataError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceMetricDataError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstanceMetricDataError::Service(ref cause) => write!(f, "{}", cause),
GetInstanceMetricDataError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetInstancePortStatesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstancePortStatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstancePortStatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstancePortStatesError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetInstancePortStatesError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetInstancePortStatesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstancePortStatesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstancePortStatesError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetInstancePortStatesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstancePortStatesError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstancePortStatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstancePortStatesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstancePortStatesError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstancePortStatesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstancePortStatesError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstancePortStatesError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstancePortStatesError::Service(ref cause) => write!(f, "{}", cause),
GetInstancePortStatesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstancePortStatesError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstanceSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstanceSnapshotError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetInstanceSnapshotError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetInstanceSnapshotError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceSnapshotError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstanceSnapshotError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetInstanceSnapshotError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstanceSnapshotError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotError::Service(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceSnapshotsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstanceSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstanceSnapshotsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetInstanceSnapshotsError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetInstanceSnapshotsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceSnapshotsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstanceSnapshotsError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetInstanceSnapshotsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstanceSnapshotsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceSnapshotsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotsError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotsError::Service(ref cause) => write!(f, "{}", cause),
GetInstanceSnapshotsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum GetInstanceStateError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstanceStateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstanceStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstanceStateError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetInstanceStateError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetInstanceStateError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstanceStateError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstanceStateError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetInstanceStateError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstanceStateError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstanceStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstanceStateError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstanceStateError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstanceStateError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstanceStateError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstanceStateError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstanceStateError::Service(ref cause) => write!(f, "{}", cause),
GetInstanceStateError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstanceStateError {}
#[derive(Debug, PartialEq)]
pub enum GetInstancesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetInstancesError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetInstancesError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetInstancesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetInstancesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetInstancesError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetInstancesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetInstancesError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInstancesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInstancesError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetInstancesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetInstancesError::NotFound(ref cause) => write!(f, "{}", cause),
GetInstancesError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetInstancesError::Service(ref cause) => write!(f, "{}", cause),
GetInstancesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInstancesError {}
#[derive(Debug, PartialEq)]
pub enum GetKeyPairError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetKeyPairError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetKeyPairError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetKeyPairError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetKeyPairError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetKeyPairError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetKeyPairError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetKeyPairError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetKeyPairError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetKeyPairError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetKeyPairError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetKeyPairError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetKeyPairError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetKeyPairError::NotFound(ref cause) => write!(f, "{}", cause),
GetKeyPairError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetKeyPairError::Service(ref cause) => write!(f, "{}", cause),
GetKeyPairError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetKeyPairError {}
#[derive(Debug, PartialEq)]
pub enum GetKeyPairsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetKeyPairsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetKeyPairsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetKeyPairsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetKeyPairsError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetKeyPairsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetKeyPairsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetKeyPairsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetKeyPairsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetKeyPairsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetKeyPairsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetKeyPairsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetKeyPairsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetKeyPairsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetKeyPairsError::NotFound(ref cause) => write!(f, "{}", cause),
GetKeyPairsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetKeyPairsError::Service(ref cause) => write!(f, "{}", cause),
GetKeyPairsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetKeyPairsError {}
#[derive(Debug, PartialEq)]
pub enum GetLoadBalancerError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetLoadBalancerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLoadBalancerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLoadBalancerError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetLoadBalancerError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetLoadBalancerError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetLoadBalancerError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetLoadBalancerError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetLoadBalancerError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetLoadBalancerError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLoadBalancerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLoadBalancerError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLoadBalancerError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetLoadBalancerError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetLoadBalancerError::NotFound(ref cause) => write!(f, "{}", cause),
GetLoadBalancerError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetLoadBalancerError::Service(ref cause) => write!(f, "{}", cause),
GetLoadBalancerError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLoadBalancerError {}
#[derive(Debug, PartialEq)]
pub enum GetLoadBalancerMetricDataError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetLoadBalancerMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLoadBalancerMetricDataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLoadBalancerMetricDataError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetLoadBalancerMetricDataError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetLoadBalancerMetricDataError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetLoadBalancerMetricDataError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetLoadBalancerMetricDataError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetLoadBalancerMetricDataError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetLoadBalancerMetricDataError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLoadBalancerMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLoadBalancerMetricDataError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLoadBalancerMetricDataError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetLoadBalancerMetricDataError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetLoadBalancerMetricDataError::NotFound(ref cause) => write!(f, "{}", cause),
GetLoadBalancerMetricDataError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetLoadBalancerMetricDataError::Service(ref cause) => write!(f, "{}", cause),
GetLoadBalancerMetricDataError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLoadBalancerMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetLoadBalancerTlsCertificatesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetLoadBalancerTlsCertificatesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetLoadBalancerTlsCertificatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLoadBalancerTlsCertificatesError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetLoadBalancerTlsCertificatesError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetLoadBalancerTlsCertificatesError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetLoadBalancerTlsCertificatesError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetLoadBalancerTlsCertificatesError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetLoadBalancerTlsCertificatesError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetLoadBalancerTlsCertificatesError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLoadBalancerTlsCertificatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLoadBalancerTlsCertificatesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLoadBalancerTlsCertificatesError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetLoadBalancerTlsCertificatesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetLoadBalancerTlsCertificatesError::NotFound(ref cause) => write!(f, "{}", cause),
GetLoadBalancerTlsCertificatesError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetLoadBalancerTlsCertificatesError::Service(ref cause) => write!(f, "{}", cause),
GetLoadBalancerTlsCertificatesError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetLoadBalancerTlsCertificatesError {}
#[derive(Debug, PartialEq)]
pub enum GetLoadBalancersError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetLoadBalancersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLoadBalancersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLoadBalancersError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetLoadBalancersError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetLoadBalancersError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetLoadBalancersError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetLoadBalancersError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetLoadBalancersError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetLoadBalancersError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLoadBalancersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLoadBalancersError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLoadBalancersError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetLoadBalancersError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetLoadBalancersError::NotFound(ref cause) => write!(f, "{}", cause),
GetLoadBalancersError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetLoadBalancersError::Service(ref cause) => write!(f, "{}", cause),
GetLoadBalancersError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLoadBalancersError {}
#[derive(Debug, PartialEq)]
pub enum GetOperationError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetOperationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOperationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetOperationError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetOperationError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetOperationError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetOperationError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetOperationError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetOperationError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetOperationError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOperationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOperationError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetOperationError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetOperationError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetOperationError::NotFound(ref cause) => write!(f, "{}", cause),
GetOperationError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetOperationError::Service(ref cause) => write!(f, "{}", cause),
GetOperationError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetOperationError {}
#[derive(Debug, PartialEq)]
pub enum GetOperationsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetOperationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOperationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetOperationsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetOperationsError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(GetOperationsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetOperationsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetOperationsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetOperationsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetOperationsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOperationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOperationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetOperationsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetOperationsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetOperationsError::NotFound(ref cause) => write!(f, "{}", cause),
GetOperationsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetOperationsError::Service(ref cause) => write!(f, "{}", cause),
GetOperationsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetOperationsError {}
#[derive(Debug, PartialEq)]
pub enum GetOperationsForResourceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetOperationsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOperationsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetOperationsForResourceError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetOperationsForResourceError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetOperationsForResourceError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetOperationsForResourceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetOperationsForResourceError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetOperationsForResourceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetOperationsForResourceError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOperationsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOperationsForResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetOperationsForResourceError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetOperationsForResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetOperationsForResourceError::NotFound(ref cause) => write!(f, "{}", cause),
GetOperationsForResourceError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetOperationsForResourceError::Service(ref cause) => write!(f, "{}", cause),
GetOperationsForResourceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetOperationsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum GetRegionsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRegionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRegionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRegionsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetRegionsError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetRegionsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetRegionsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetRegionsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetRegionsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetRegionsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRegionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRegionsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRegionsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetRegionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRegionsError::NotFound(ref cause) => write!(f, "{}", cause),
GetRegionsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetRegionsError::Service(ref cause) => write!(f, "{}", cause),
GetRegionsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRegionsError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabaseError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabaseError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseBlueprintsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseBlueprintsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseBlueprintsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetRelationalDatabaseBlueprintsError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseBlueprintsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
GetRelationalDatabaseBlueprintsError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseBlueprintsError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseBlueprintsError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseBlueprintsError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseBlueprintsError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseBlueprintsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseBlueprintsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBlueprintsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseBlueprintsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBlueprintsError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBlueprintsError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseBlueprintsError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBlueprintsError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseBlueprintsError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseBundlesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseBundlesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseBundlesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabaseBundlesError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseBundlesError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabaseBundlesError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseBundlesError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseBundlesError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseBundlesError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseBundlesError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseBundlesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseBundlesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBundlesError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseBundlesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBundlesError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBundlesError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseBundlesError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseBundlesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRelationalDatabaseBundlesError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseEventsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseEventsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseEventsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabaseEventsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseEventsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabaseEventsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseEventsError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseEventsError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseEventsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetRelationalDatabaseEventsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseEventsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseEventsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseEventsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseEventsError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseEventsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseEventsError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseEventsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRelationalDatabaseEventsError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseLogEventsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseLogEventsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseLogEventsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabaseLogEventsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseLogEventsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabaseLogEventsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseLogEventsError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseLogEventsError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseLogEventsError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseLogEventsError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseLogEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseLogEventsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogEventsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseLogEventsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogEventsError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogEventsError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseLogEventsError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogEventsError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseLogEventsError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseLogStreamsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseLogStreamsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseLogStreamsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetRelationalDatabaseLogStreamsError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseLogStreamsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
GetRelationalDatabaseLogStreamsError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseLogStreamsError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseLogStreamsError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseLogStreamsError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseLogStreamsError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseLogStreamsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseLogStreamsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogStreamsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseLogStreamsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogStreamsError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogStreamsError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseLogStreamsError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseLogStreamsError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseLogStreamsError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseMasterUserPasswordError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseMasterUserPasswordError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseMasterUserPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::AccountSetupInProgress(
err.msg,
),
)
}
"InvalidInputException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::NotFound(err.msg),
)
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::Service(err.msg),
)
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseMasterUserPasswordError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseMasterUserPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseMasterUserPasswordError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMasterUserPasswordError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMasterUserPasswordError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMasterUserPasswordError::NotFound(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMasterUserPasswordError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMasterUserPasswordError::Service(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMasterUserPasswordError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseMasterUserPasswordError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseMetricDataError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseMetricDataError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseMetricDataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetRelationalDatabaseMetricDataError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseMetricDataError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
GetRelationalDatabaseMetricDataError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseMetricDataError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseMetricDataError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseMetricDataError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseMetricDataError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseMetricDataError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseMetricDataError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMetricDataError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseMetricDataError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseMetricDataError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseMetricDataError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseMetricDataError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseParametersError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseParametersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseParametersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetRelationalDatabaseParametersError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseParametersError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
GetRelationalDatabaseParametersError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseParametersError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseParametersError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseParametersError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseParametersError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseParametersError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseParametersError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseParametersError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseParametersError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseParametersError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseParametersError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseParametersError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseParametersError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseSnapshotError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseSnapshotError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseSnapshotError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseSnapshotError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseSnapshotError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseSnapshotError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseSnapshotError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabaseSnapshotsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabaseSnapshotsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRelationalDatabaseSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabaseSnapshotsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotsError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
GetRelationalDatabaseSnapshotsError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabaseSnapshotsError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
GetRelationalDatabaseSnapshotsError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabaseSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabaseSnapshotsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseSnapshotsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotsError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotsError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabaseSnapshotsError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabaseSnapshotsError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRelationalDatabaseSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum GetRelationalDatabasesError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetRelationalDatabasesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRelationalDatabasesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRelationalDatabasesError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
GetRelationalDatabasesError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetRelationalDatabasesError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetRelationalDatabasesError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetRelationalDatabasesError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetRelationalDatabasesError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetRelationalDatabasesError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRelationalDatabasesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRelationalDatabasesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRelationalDatabasesError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
GetRelationalDatabasesError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetRelationalDatabasesError::NotFound(ref cause) => write!(f, "{}", cause),
GetRelationalDatabasesError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetRelationalDatabasesError::Service(ref cause) => write!(f, "{}", cause),
GetRelationalDatabasesError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRelationalDatabasesError {}
#[derive(Debug, PartialEq)]
pub enum GetStaticIpError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetStaticIpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetStaticIpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetStaticIpError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetStaticIpError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetStaticIpError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetStaticIpError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetStaticIpError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetStaticIpError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetStaticIpError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetStaticIpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetStaticIpError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetStaticIpError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetStaticIpError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetStaticIpError::NotFound(ref cause) => write!(f, "{}", cause),
GetStaticIpError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetStaticIpError::Service(ref cause) => write!(f, "{}", cause),
GetStaticIpError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetStaticIpError {}
#[derive(Debug, PartialEq)]
pub enum GetStaticIpsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl GetStaticIpsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetStaticIpsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetStaticIpsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(GetStaticIpsError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetStaticIpsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetStaticIpsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(GetStaticIpsError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetStaticIpsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(GetStaticIpsError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetStaticIpsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetStaticIpsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetStaticIpsError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
GetStaticIpsError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetStaticIpsError::NotFound(ref cause) => write!(f, "{}", cause),
GetStaticIpsError::OperationFailure(ref cause) => write!(f, "{}", cause),
GetStaticIpsError::Service(ref cause) => write!(f, "{}", cause),
GetStaticIpsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetStaticIpsError {}
#[derive(Debug, PartialEq)]
pub enum ImportKeyPairError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl ImportKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportKeyPairError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ImportKeyPairError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(ImportKeyPairError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ImportKeyPairError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ImportKeyPairError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(ImportKeyPairError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ImportKeyPairError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(ImportKeyPairError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ImportKeyPairError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImportKeyPairError::AccessDenied(ref cause) => write!(f, "{}", cause),
ImportKeyPairError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
ImportKeyPairError::InvalidInput(ref cause) => write!(f, "{}", cause),
ImportKeyPairError::NotFound(ref cause) => write!(f, "{}", cause),
ImportKeyPairError::OperationFailure(ref cause) => write!(f, "{}", cause),
ImportKeyPairError::Service(ref cause) => write!(f, "{}", cause),
ImportKeyPairError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ImportKeyPairError {}
#[derive(Debug, PartialEq)]
pub enum IsVpcPeeredError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl IsVpcPeeredError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<IsVpcPeeredError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(IsVpcPeeredError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(IsVpcPeeredError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(IsVpcPeeredError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(IsVpcPeeredError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(IsVpcPeeredError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(IsVpcPeeredError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(IsVpcPeeredError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for IsVpcPeeredError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
IsVpcPeeredError::AccessDenied(ref cause) => write!(f, "{}", cause),
IsVpcPeeredError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
IsVpcPeeredError::InvalidInput(ref cause) => write!(f, "{}", cause),
IsVpcPeeredError::NotFound(ref cause) => write!(f, "{}", cause),
IsVpcPeeredError::OperationFailure(ref cause) => write!(f, "{}", cause),
IsVpcPeeredError::Service(ref cause) => write!(f, "{}", cause),
IsVpcPeeredError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for IsVpcPeeredError {}
#[derive(Debug, PartialEq)]
pub enum OpenInstancePublicPortsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl OpenInstancePublicPortsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<OpenInstancePublicPortsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(OpenInstancePublicPortsError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
OpenInstancePublicPortsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(OpenInstancePublicPortsError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(OpenInstancePublicPortsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(OpenInstancePublicPortsError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(OpenInstancePublicPortsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(OpenInstancePublicPortsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for OpenInstancePublicPortsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
OpenInstancePublicPortsError::AccessDenied(ref cause) => write!(f, "{}", cause),
OpenInstancePublicPortsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
OpenInstancePublicPortsError::InvalidInput(ref cause) => write!(f, "{}", cause),
OpenInstancePublicPortsError::NotFound(ref cause) => write!(f, "{}", cause),
OpenInstancePublicPortsError::OperationFailure(ref cause) => write!(f, "{}", cause),
OpenInstancePublicPortsError::Service(ref cause) => write!(f, "{}", cause),
OpenInstancePublicPortsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for OpenInstancePublicPortsError {}
#[derive(Debug, PartialEq)]
pub enum PeerVpcError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl PeerVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PeerVpcError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PeerVpcError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(PeerVpcError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(PeerVpcError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(PeerVpcError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(PeerVpcError::OperationFailure(err.msg))
}
"ServiceException" => return RusotoError::Service(PeerVpcError::Service(err.msg)),
"UnauthenticatedException" => {
return RusotoError::Service(PeerVpcError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PeerVpcError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PeerVpcError::AccessDenied(ref cause) => write!(f, "{}", cause),
PeerVpcError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
PeerVpcError::InvalidInput(ref cause) => write!(f, "{}", cause),
PeerVpcError::NotFound(ref cause) => write!(f, "{}", cause),
PeerVpcError::OperationFailure(ref cause) => write!(f, "{}", cause),
PeerVpcError::Service(ref cause) => write!(f, "{}", cause),
PeerVpcError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PeerVpcError {}
#[derive(Debug, PartialEq)]
pub enum PutAlarmError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl PutAlarmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutAlarmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PutAlarmError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(PutAlarmError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(PutAlarmError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(PutAlarmError::OperationFailure(err.msg))
}
"ServiceException" => return RusotoError::Service(PutAlarmError::Service(err.msg)),
"UnauthenticatedException" => {
return RusotoError::Service(PutAlarmError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAlarmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAlarmError::AccessDenied(ref cause) => write!(f, "{}", cause),
PutAlarmError::InvalidInput(ref cause) => write!(f, "{}", cause),
PutAlarmError::NotFound(ref cause) => write!(f, "{}", cause),
PutAlarmError::OperationFailure(ref cause) => write!(f, "{}", cause),
PutAlarmError::Service(ref cause) => write!(f, "{}", cause),
PutAlarmError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutAlarmError {}
#[derive(Debug, PartialEq)]
pub enum PutInstancePublicPortsError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl PutInstancePublicPortsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutInstancePublicPortsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PutInstancePublicPortsError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
PutInstancePublicPortsError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(PutInstancePublicPortsError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(PutInstancePublicPortsError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(PutInstancePublicPortsError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(PutInstancePublicPortsError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(PutInstancePublicPortsError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutInstancePublicPortsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutInstancePublicPortsError::AccessDenied(ref cause) => write!(f, "{}", cause),
PutInstancePublicPortsError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
PutInstancePublicPortsError::InvalidInput(ref cause) => write!(f, "{}", cause),
PutInstancePublicPortsError::NotFound(ref cause) => write!(f, "{}", cause),
PutInstancePublicPortsError::OperationFailure(ref cause) => write!(f, "{}", cause),
PutInstancePublicPortsError::Service(ref cause) => write!(f, "{}", cause),
PutInstancePublicPortsError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutInstancePublicPortsError {}
#[derive(Debug, PartialEq)]
pub enum RebootInstanceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl RebootInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebootInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RebootInstanceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(RebootInstanceError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(RebootInstanceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(RebootInstanceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(RebootInstanceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(RebootInstanceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(RebootInstanceError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RebootInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RebootInstanceError::AccessDenied(ref cause) => write!(f, "{}", cause),
RebootInstanceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
RebootInstanceError::InvalidInput(ref cause) => write!(f, "{}", cause),
RebootInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
RebootInstanceError::OperationFailure(ref cause) => write!(f, "{}", cause),
RebootInstanceError::Service(ref cause) => write!(f, "{}", cause),
RebootInstanceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RebootInstanceError {}
#[derive(Debug, PartialEq)]
pub enum RebootRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl RebootRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebootRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RebootRelationalDatabaseError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
RebootRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(RebootRelationalDatabaseError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(RebootRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(RebootRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(RebootRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(RebootRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RebootRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RebootRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
RebootRelationalDatabaseError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
RebootRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
RebootRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
RebootRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
RebootRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
RebootRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RebootRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum RegisterContainerImageError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl RegisterContainerImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterContainerImageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RegisterContainerImageError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(RegisterContainerImageError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(RegisterContainerImageError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(RegisterContainerImageError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(RegisterContainerImageError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterContainerImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterContainerImageError::AccessDenied(ref cause) => write!(f, "{}", cause),
RegisterContainerImageError::InvalidInput(ref cause) => write!(f, "{}", cause),
RegisterContainerImageError::NotFound(ref cause) => write!(f, "{}", cause),
RegisterContainerImageError::Service(ref cause) => write!(f, "{}", cause),
RegisterContainerImageError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterContainerImageError {}
#[derive(Debug, PartialEq)]
pub enum ReleaseStaticIpError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl ReleaseStaticIpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReleaseStaticIpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ReleaseStaticIpError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(ReleaseStaticIpError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ReleaseStaticIpError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ReleaseStaticIpError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(ReleaseStaticIpError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ReleaseStaticIpError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(ReleaseStaticIpError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ReleaseStaticIpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ReleaseStaticIpError::AccessDenied(ref cause) => write!(f, "{}", cause),
ReleaseStaticIpError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
ReleaseStaticIpError::InvalidInput(ref cause) => write!(f, "{}", cause),
ReleaseStaticIpError::NotFound(ref cause) => write!(f, "{}", cause),
ReleaseStaticIpError::OperationFailure(ref cause) => write!(f, "{}", cause),
ReleaseStaticIpError::Service(ref cause) => write!(f, "{}", cause),
ReleaseStaticIpError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ReleaseStaticIpError {}
#[derive(Debug, PartialEq)]
pub enum ResetDistributionCacheError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl ResetDistributionCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetDistributionCacheError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ResetDistributionCacheError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(ResetDistributionCacheError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ResetDistributionCacheError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(ResetDistributionCacheError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ResetDistributionCacheError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(ResetDistributionCacheError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ResetDistributionCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResetDistributionCacheError::AccessDenied(ref cause) => write!(f, "{}", cause),
ResetDistributionCacheError::InvalidInput(ref cause) => write!(f, "{}", cause),
ResetDistributionCacheError::NotFound(ref cause) => write!(f, "{}", cause),
ResetDistributionCacheError::OperationFailure(ref cause) => write!(f, "{}", cause),
ResetDistributionCacheError::Service(ref cause) => write!(f, "{}", cause),
ResetDistributionCacheError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResetDistributionCacheError {}
#[derive(Debug, PartialEq)]
pub enum SendContactMethodVerificationError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl SendContactMethodVerificationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<SendContactMethodVerificationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(SendContactMethodVerificationError::AccessDenied(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(SendContactMethodVerificationError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(SendContactMethodVerificationError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
SendContactMethodVerificationError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(SendContactMethodVerificationError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
SendContactMethodVerificationError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SendContactMethodVerificationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SendContactMethodVerificationError::AccessDenied(ref cause) => write!(f, "{}", cause),
SendContactMethodVerificationError::InvalidInput(ref cause) => write!(f, "{}", cause),
SendContactMethodVerificationError::NotFound(ref cause) => write!(f, "{}", cause),
SendContactMethodVerificationError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
SendContactMethodVerificationError::Service(ref cause) => write!(f, "{}", cause),
SendContactMethodVerificationError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for SendContactMethodVerificationError {}
#[derive(Debug, PartialEq)]
pub enum StartInstanceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl StartInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(StartInstanceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(StartInstanceError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(StartInstanceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StartInstanceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(StartInstanceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(StartInstanceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(StartInstanceError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartInstanceError::AccessDenied(ref cause) => write!(f, "{}", cause),
StartInstanceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
StartInstanceError::InvalidInput(ref cause) => write!(f, "{}", cause),
StartInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
StartInstanceError::OperationFailure(ref cause) => write!(f, "{}", cause),
StartInstanceError::Service(ref cause) => write!(f, "{}", cause),
StartInstanceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartInstanceError {}
#[derive(Debug, PartialEq)]
pub enum StartRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl StartRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(StartRelationalDatabaseError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
StartRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(StartRelationalDatabaseError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(StartRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(StartRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(StartRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(StartRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
StartRelationalDatabaseError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
StartRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
StartRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
StartRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
StartRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
StartRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum StopInstanceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl StopInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(StopInstanceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(StopInstanceError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(StopInstanceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StopInstanceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(StopInstanceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(StopInstanceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(StopInstanceError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopInstanceError::AccessDenied(ref cause) => write!(f, "{}", cause),
StopInstanceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
StopInstanceError::InvalidInput(ref cause) => write!(f, "{}", cause),
StopInstanceError::NotFound(ref cause) => write!(f, "{}", cause),
StopInstanceError::OperationFailure(ref cause) => write!(f, "{}", cause),
StopInstanceError::Service(ref cause) => write!(f, "{}", cause),
StopInstanceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopInstanceError {}
#[derive(Debug, PartialEq)]
pub enum StopRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl StopRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(StopRelationalDatabaseError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
StopRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(StopRelationalDatabaseError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StopRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(StopRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(StopRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(StopRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
StopRelationalDatabaseError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
StopRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
StopRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
StopRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
StopRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
StopRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(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() {
"AccessDeniedException" => {
return RusotoError::Service(TagResourceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(TagResourceError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(TagResourceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(TagResourceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(TagResourceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(TagResourceError::Unauthenticated(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::AccessDenied(ref cause) => write!(f, "{}", cause),
TagResourceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::OperationFailure(ref cause) => write!(f, "{}", cause),
TagResourceError::Service(ref cause) => write!(f, "{}", cause),
TagResourceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum TestAlarmError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl TestAlarmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TestAlarmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(TestAlarmError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(TestAlarmError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TestAlarmError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(TestAlarmError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(TestAlarmError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(TestAlarmError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TestAlarmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TestAlarmError::AccessDenied(ref cause) => write!(f, "{}", cause),
TestAlarmError::InvalidInput(ref cause) => write!(f, "{}", cause),
TestAlarmError::NotFound(ref cause) => write!(f, "{}", cause),
TestAlarmError::OperationFailure(ref cause) => write!(f, "{}", cause),
TestAlarmError::Service(ref cause) => write!(f, "{}", cause),
TestAlarmError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TestAlarmError {}
#[derive(Debug, PartialEq)]
pub enum UnpeerVpcError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UnpeerVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnpeerVpcError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UnpeerVpcError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(UnpeerVpcError::AccountSetupInProgress(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(UnpeerVpcError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UnpeerVpcError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(UnpeerVpcError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UnpeerVpcError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UnpeerVpcError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UnpeerVpcError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UnpeerVpcError::AccessDenied(ref cause) => write!(f, "{}", cause),
UnpeerVpcError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
UnpeerVpcError::InvalidInput(ref cause) => write!(f, "{}", cause),
UnpeerVpcError::NotFound(ref cause) => write!(f, "{}", cause),
UnpeerVpcError::OperationFailure(ref cause) => write!(f, "{}", cause),
UnpeerVpcError::Service(ref cause) => write!(f, "{}", cause),
UnpeerVpcError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UnpeerVpcError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(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() {
"AccessDeniedException" => {
return RusotoError::Service(UntagResourceError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(UntagResourceError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(UntagResourceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(UntagResourceError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UntagResourceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UntagResourceError::Unauthenticated(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::AccessDenied(ref cause) => write!(f, "{}", cause),
UntagResourceError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::OperationFailure(ref cause) => write!(f, "{}", cause),
UntagResourceError::Service(ref cause) => write!(f, "{}", cause),
UntagResourceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateContainerServiceError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
Service(String),
Unauthenticated(String),
}
impl UpdateContainerServiceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateContainerServiceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateContainerServiceError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(UpdateContainerServiceError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateContainerServiceError::NotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateContainerServiceError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UpdateContainerServiceError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateContainerServiceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateContainerServiceError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateContainerServiceError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateContainerServiceError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateContainerServiceError::Service(ref cause) => write!(f, "{}", cause),
UpdateContainerServiceError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateContainerServiceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDistributionError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UpdateDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDistributionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateDistributionError::AccessDenied(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(UpdateDistributionError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDistributionError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(UpdateDistributionError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateDistributionError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UpdateDistributionError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::OperationFailure(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::Service(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDistributionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDistributionBundleError {
AccessDenied(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UpdateDistributionBundleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDistributionBundleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateDistributionBundleError::AccessDenied(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(UpdateDistributionBundleError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDistributionBundleError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(UpdateDistributionBundleError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(UpdateDistributionBundleError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UpdateDistributionBundleError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDistributionBundleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDistributionBundleError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateDistributionBundleError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateDistributionBundleError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDistributionBundleError::OperationFailure(ref cause) => write!(f, "{}", cause),
UpdateDistributionBundleError::Service(ref cause) => write!(f, "{}", cause),
UpdateDistributionBundleError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDistributionBundleError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDomainEntryError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UpdateDomainEntryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDomainEntryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateDomainEntryError::AccessDenied(err.msg))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(UpdateDomainEntryError::AccountSetupInProgress(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(UpdateDomainEntryError::InvalidInput(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDomainEntryError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(UpdateDomainEntryError::OperationFailure(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateDomainEntryError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UpdateDomainEntryError::Unauthenticated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDomainEntryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDomainEntryError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateDomainEntryError::AccountSetupInProgress(ref cause) => write!(f, "{}", cause),
UpdateDomainEntryError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateDomainEntryError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDomainEntryError::OperationFailure(ref cause) => write!(f, "{}", cause),
UpdateDomainEntryError::Service(ref cause) => write!(f, "{}", cause),
UpdateDomainEntryError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDomainEntryError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLoadBalancerAttributeError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UpdateLoadBalancerAttributeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateLoadBalancerAttributeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateLoadBalancerAttributeError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
UpdateLoadBalancerAttributeError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(UpdateLoadBalancerAttributeError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateLoadBalancerAttributeError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
UpdateLoadBalancerAttributeError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateLoadBalancerAttributeError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UpdateLoadBalancerAttributeError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLoadBalancerAttributeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLoadBalancerAttributeError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateLoadBalancerAttributeError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
UpdateLoadBalancerAttributeError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateLoadBalancerAttributeError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateLoadBalancerAttributeError::OperationFailure(ref cause) => write!(f, "{}", cause),
UpdateLoadBalancerAttributeError::Service(ref cause) => write!(f, "{}", cause),
UpdateLoadBalancerAttributeError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateLoadBalancerAttributeError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRelationalDatabaseError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UpdateRelationalDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRelationalDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateRelationalDatabaseError::AccessDenied(
err.msg,
))
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
UpdateRelationalDatabaseError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(UpdateRelationalDatabaseError::InvalidInput(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateRelationalDatabaseError::NotFound(err.msg))
}
"OperationFailureException" => {
return RusotoError::Service(UpdateRelationalDatabaseError::OperationFailure(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(UpdateRelationalDatabaseError::Service(err.msg))
}
"UnauthenticatedException" => {
return RusotoError::Service(UpdateRelationalDatabaseError::Unauthenticated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRelationalDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRelationalDatabaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
UpdateRelationalDatabaseError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseError::OperationFailure(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseError::Service(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseError::Unauthenticated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRelationalDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRelationalDatabaseParametersError {
AccessDenied(String),
AccountSetupInProgress(String),
InvalidInput(String),
NotFound(String),
OperationFailure(String),
Service(String),
Unauthenticated(String),
}
impl UpdateRelationalDatabaseParametersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateRelationalDatabaseParametersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
UpdateRelationalDatabaseParametersError::AccessDenied(err.msg),
)
}
"AccountSetupInProgressException" => {
return RusotoError::Service(
UpdateRelationalDatabaseParametersError::AccountSetupInProgress(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(
UpdateRelationalDatabaseParametersError::InvalidInput(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(UpdateRelationalDatabaseParametersError::NotFound(
err.msg,
))
}
"OperationFailureException" => {
return RusotoError::Service(
UpdateRelationalDatabaseParametersError::OperationFailure(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateRelationalDatabaseParametersError::Service(
err.msg,
))
}
"UnauthenticatedException" => {
return RusotoError::Service(
UpdateRelationalDatabaseParametersError::Unauthenticated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRelationalDatabaseParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRelationalDatabaseParametersError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdateRelationalDatabaseParametersError::AccountSetupInProgress(ref cause) => {
write!(f, "{}", cause)
}
UpdateRelationalDatabaseParametersError::InvalidInput(ref cause) => {
write!(f, "{}", cause)
}
UpdateRelationalDatabaseParametersError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseParametersError::OperationFailure(ref cause) => {
write!(f, "{}", cause)
}
UpdateRelationalDatabaseParametersError::Service(ref cause) => write!(f, "{}", cause),
UpdateRelationalDatabaseParametersError::Unauthenticated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateRelationalDatabaseParametersError {}
#[async_trait]
pub trait Lightsail {
async fn allocate_static_ip(
&self,
input: AllocateStaticIpRequest,
) -> Result<AllocateStaticIpResult, RusotoError<AllocateStaticIpError>>;
async fn attach_certificate_to_distribution(
&self,
input: AttachCertificateToDistributionRequest,
) -> Result<
AttachCertificateToDistributionResult,
RusotoError<AttachCertificateToDistributionError>,
>;
async fn attach_disk(
&self,
input: AttachDiskRequest,
) -> Result<AttachDiskResult, RusotoError<AttachDiskError>>;
async fn attach_instances_to_load_balancer(
&self,
input: AttachInstancesToLoadBalancerRequest,
) -> Result<AttachInstancesToLoadBalancerResult, RusotoError<AttachInstancesToLoadBalancerError>>;
async fn attach_load_balancer_tls_certificate(
&self,
input: AttachLoadBalancerTlsCertificateRequest,
) -> Result<
AttachLoadBalancerTlsCertificateResult,
RusotoError<AttachLoadBalancerTlsCertificateError>,
>;
async fn attach_static_ip(
&self,
input: AttachStaticIpRequest,
) -> Result<AttachStaticIpResult, RusotoError<AttachStaticIpError>>;
async fn close_instance_public_ports(
&self,
input: CloseInstancePublicPortsRequest,
) -> Result<CloseInstancePublicPortsResult, RusotoError<CloseInstancePublicPortsError>>;
async fn copy_snapshot(
&self,
input: CopySnapshotRequest,
) -> Result<CopySnapshotResult, RusotoError<CopySnapshotError>>;
async fn create_certificate(
&self,
input: CreateCertificateRequest,
) -> Result<CreateCertificateResult, RusotoError<CreateCertificateError>>;
async fn create_cloud_formation_stack(
&self,
input: CreateCloudFormationStackRequest,
) -> Result<CreateCloudFormationStackResult, RusotoError<CreateCloudFormationStackError>>;
async fn create_contact_method(
&self,
input: CreateContactMethodRequest,
) -> Result<CreateContactMethodResult, RusotoError<CreateContactMethodError>>;
async fn create_container_service(
&self,
input: CreateContainerServiceRequest,
) -> Result<CreateContainerServiceResult, RusotoError<CreateContainerServiceError>>;
async fn create_container_service_deployment(
&self,
input: CreateContainerServiceDeploymentRequest,
) -> Result<
CreateContainerServiceDeploymentResult,
RusotoError<CreateContainerServiceDeploymentError>,
>;
async fn create_container_service_registry_login(
&self,
) -> Result<
CreateContainerServiceRegistryLoginResult,
RusotoError<CreateContainerServiceRegistryLoginError>,
>;
async fn create_disk(
&self,
input: CreateDiskRequest,
) -> Result<CreateDiskResult, RusotoError<CreateDiskError>>;
async fn create_disk_from_snapshot(
&self,
input: CreateDiskFromSnapshotRequest,
) -> Result<CreateDiskFromSnapshotResult, RusotoError<CreateDiskFromSnapshotError>>;
async fn create_disk_snapshot(
&self,
input: CreateDiskSnapshotRequest,
) -> Result<CreateDiskSnapshotResult, RusotoError<CreateDiskSnapshotError>>;
async fn create_distribution(
&self,
input: CreateDistributionRequest,
) -> Result<CreateDistributionResult, RusotoError<CreateDistributionError>>;
async fn create_domain(
&self,
input: CreateDomainRequest,
) -> Result<CreateDomainResult, RusotoError<CreateDomainError>>;
async fn create_domain_entry(
&self,
input: CreateDomainEntryRequest,
) -> Result<CreateDomainEntryResult, RusotoError<CreateDomainEntryError>>;
async fn create_instance_snapshot(
&self,
input: CreateInstanceSnapshotRequest,
) -> Result<CreateInstanceSnapshotResult, RusotoError<CreateInstanceSnapshotError>>;
async fn create_instances(
&self,
input: CreateInstancesRequest,
) -> Result<CreateInstancesResult, RusotoError<CreateInstancesError>>;
async fn create_instances_from_snapshot(
&self,
input: CreateInstancesFromSnapshotRequest,
) -> Result<CreateInstancesFromSnapshotResult, RusotoError<CreateInstancesFromSnapshotError>>;
async fn create_key_pair(
&self,
input: CreateKeyPairRequest,
) -> Result<CreateKeyPairResult, RusotoError<CreateKeyPairError>>;
async fn create_load_balancer(
&self,
input: CreateLoadBalancerRequest,
) -> Result<CreateLoadBalancerResult, RusotoError<CreateLoadBalancerError>>;
async fn create_load_balancer_tls_certificate(
&self,
input: CreateLoadBalancerTlsCertificateRequest,
) -> Result<
CreateLoadBalancerTlsCertificateResult,
RusotoError<CreateLoadBalancerTlsCertificateError>,
>;
async fn create_relational_database(
&self,
input: CreateRelationalDatabaseRequest,
) -> Result<CreateRelationalDatabaseResult, RusotoError<CreateRelationalDatabaseError>>;
async fn create_relational_database_from_snapshot(
&self,
input: CreateRelationalDatabaseFromSnapshotRequest,
) -> Result<
CreateRelationalDatabaseFromSnapshotResult,
RusotoError<CreateRelationalDatabaseFromSnapshotError>,
>;
async fn create_relational_database_snapshot(
&self,
input: CreateRelationalDatabaseSnapshotRequest,
) -> Result<
CreateRelationalDatabaseSnapshotResult,
RusotoError<CreateRelationalDatabaseSnapshotError>,
>;
async fn delete_alarm(
&self,
input: DeleteAlarmRequest,
) -> Result<DeleteAlarmResult, RusotoError<DeleteAlarmError>>;
async fn delete_auto_snapshot(
&self,
input: DeleteAutoSnapshotRequest,
) -> Result<DeleteAutoSnapshotResult, RusotoError<DeleteAutoSnapshotError>>;
async fn delete_certificate(
&self,
input: DeleteCertificateRequest,
) -> Result<DeleteCertificateResult, RusotoError<DeleteCertificateError>>;
async fn delete_contact_method(
&self,
input: DeleteContactMethodRequest,
) -> Result<DeleteContactMethodResult, RusotoError<DeleteContactMethodError>>;
async fn delete_container_image(
&self,
input: DeleteContainerImageRequest,
) -> Result<DeleteContainerImageResult, RusotoError<DeleteContainerImageError>>;
async fn delete_container_service(
&self,
input: DeleteContainerServiceRequest,
) -> Result<DeleteContainerServiceResult, RusotoError<DeleteContainerServiceError>>;
async fn delete_disk(
&self,
input: DeleteDiskRequest,
) -> Result<DeleteDiskResult, RusotoError<DeleteDiskError>>;
async fn delete_disk_snapshot(
&self,
input: DeleteDiskSnapshotRequest,
) -> Result<DeleteDiskSnapshotResult, RusotoError<DeleteDiskSnapshotError>>;
async fn delete_distribution(
&self,
input: DeleteDistributionRequest,
) -> Result<DeleteDistributionResult, RusotoError<DeleteDistributionError>>;
async fn delete_domain(
&self,
input: DeleteDomainRequest,
) -> Result<DeleteDomainResult, RusotoError<DeleteDomainError>>;
async fn delete_domain_entry(
&self,
input: DeleteDomainEntryRequest,
) -> Result<DeleteDomainEntryResult, RusotoError<DeleteDomainEntryError>>;
async fn delete_instance(
&self,
input: DeleteInstanceRequest,
) -> Result<DeleteInstanceResult, RusotoError<DeleteInstanceError>>;
async fn delete_instance_snapshot(
&self,
input: DeleteInstanceSnapshotRequest,
) -> Result<DeleteInstanceSnapshotResult, RusotoError<DeleteInstanceSnapshotError>>;
async fn delete_key_pair(
&self,
input: DeleteKeyPairRequest,
) -> Result<DeleteKeyPairResult, RusotoError<DeleteKeyPairError>>;
async fn delete_known_host_keys(
&self,
input: DeleteKnownHostKeysRequest,
) -> Result<DeleteKnownHostKeysResult, RusotoError<DeleteKnownHostKeysError>>;
async fn delete_load_balancer(
&self,
input: DeleteLoadBalancerRequest,
) -> Result<DeleteLoadBalancerResult, RusotoError<DeleteLoadBalancerError>>;
async fn delete_load_balancer_tls_certificate(
&self,
input: DeleteLoadBalancerTlsCertificateRequest,
) -> Result<
DeleteLoadBalancerTlsCertificateResult,
RusotoError<DeleteLoadBalancerTlsCertificateError>,
>;
async fn delete_relational_database(
&self,
input: DeleteRelationalDatabaseRequest,
) -> Result<DeleteRelationalDatabaseResult, RusotoError<DeleteRelationalDatabaseError>>;
async fn delete_relational_database_snapshot(
&self,
input: DeleteRelationalDatabaseSnapshotRequest,
) -> Result<
DeleteRelationalDatabaseSnapshotResult,
RusotoError<DeleteRelationalDatabaseSnapshotError>,
>;
async fn detach_certificate_from_distribution(
&self,
input: DetachCertificateFromDistributionRequest,
) -> Result<
DetachCertificateFromDistributionResult,
RusotoError<DetachCertificateFromDistributionError>,
>;
async fn detach_disk(
&self,
input: DetachDiskRequest,
) -> Result<DetachDiskResult, RusotoError<DetachDiskError>>;
async fn detach_instances_from_load_balancer(
&self,
input: DetachInstancesFromLoadBalancerRequest,
) -> Result<
DetachInstancesFromLoadBalancerResult,
RusotoError<DetachInstancesFromLoadBalancerError>,
>;
async fn detach_static_ip(
&self,
input: DetachStaticIpRequest,
) -> Result<DetachStaticIpResult, RusotoError<DetachStaticIpError>>;
async fn disable_add_on(
&self,
input: DisableAddOnRequest,
) -> Result<DisableAddOnResult, RusotoError<DisableAddOnError>>;
async fn download_default_key_pair(
&self,
) -> Result<DownloadDefaultKeyPairResult, RusotoError<DownloadDefaultKeyPairError>>;
async fn enable_add_on(
&self,
input: EnableAddOnRequest,
) -> Result<EnableAddOnResult, RusotoError<EnableAddOnError>>;
async fn export_snapshot(
&self,
input: ExportSnapshotRequest,
) -> Result<ExportSnapshotResult, RusotoError<ExportSnapshotError>>;
async fn get_active_names(
&self,
input: GetActiveNamesRequest,
) -> Result<GetActiveNamesResult, RusotoError<GetActiveNamesError>>;
async fn get_alarms(
&self,
input: GetAlarmsRequest,
) -> Result<GetAlarmsResult, RusotoError<GetAlarmsError>>;
async fn get_auto_snapshots(
&self,
input: GetAutoSnapshotsRequest,
) -> Result<GetAutoSnapshotsResult, RusotoError<GetAutoSnapshotsError>>;
async fn get_blueprints(
&self,
input: GetBlueprintsRequest,
) -> Result<GetBlueprintsResult, RusotoError<GetBlueprintsError>>;
async fn get_bundles(
&self,
input: GetBundlesRequest,
) -> Result<GetBundlesResult, RusotoError<GetBundlesError>>;
async fn get_certificates(
&self,
input: GetCertificatesRequest,
) -> Result<GetCertificatesResult, RusotoError<GetCertificatesError>>;
async fn get_cloud_formation_stack_records(
&self,
input: GetCloudFormationStackRecordsRequest,
) -> Result<GetCloudFormationStackRecordsResult, RusotoError<GetCloudFormationStackRecordsError>>;
async fn get_contact_methods(
&self,
input: GetContactMethodsRequest,
) -> Result<GetContactMethodsResult, RusotoError<GetContactMethodsError>>;
async fn get_container_api_metadata(
&self,
) -> Result<GetContainerAPIMetadataResult, RusotoError<GetContainerAPIMetadataError>>;
async fn get_container_images(
&self,
input: GetContainerImagesRequest,
) -> Result<GetContainerImagesResult, RusotoError<GetContainerImagesError>>;
async fn get_container_log(
&self,
input: GetContainerLogRequest,
) -> Result<GetContainerLogResult, RusotoError<GetContainerLogError>>;
async fn get_container_service_deployments(
&self,
input: GetContainerServiceDeploymentsRequest,
) -> Result<
GetContainerServiceDeploymentsResult,
RusotoError<GetContainerServiceDeploymentsError>,
>;
async fn get_container_service_metric_data(
&self,
input: GetContainerServiceMetricDataRequest,
) -> Result<GetContainerServiceMetricDataResult, RusotoError<GetContainerServiceMetricDataError>>;
async fn get_container_service_powers(
&self,
) -> Result<GetContainerServicePowersResult, RusotoError<GetContainerServicePowersError>>;
async fn get_container_services(
&self,
input: GetContainerServicesRequest,
) -> Result<ContainerServicesListResult, RusotoError<GetContainerServicesError>>;
async fn get_disk(
&self,
input: GetDiskRequest,
) -> Result<GetDiskResult, RusotoError<GetDiskError>>;
async fn get_disk_snapshot(
&self,
input: GetDiskSnapshotRequest,
) -> Result<GetDiskSnapshotResult, RusotoError<GetDiskSnapshotError>>;
async fn get_disk_snapshots(
&self,
input: GetDiskSnapshotsRequest,
) -> Result<GetDiskSnapshotsResult, RusotoError<GetDiskSnapshotsError>>;
async fn get_disks(
&self,
input: GetDisksRequest,
) -> Result<GetDisksResult, RusotoError<GetDisksError>>;
async fn get_distribution_bundles(
&self,
) -> Result<GetDistributionBundlesResult, RusotoError<GetDistributionBundlesError>>;
async fn get_distribution_latest_cache_reset(
&self,
input: GetDistributionLatestCacheResetRequest,
) -> Result<
GetDistributionLatestCacheResetResult,
RusotoError<GetDistributionLatestCacheResetError>,
>;
async fn get_distribution_metric_data(
&self,
input: GetDistributionMetricDataRequest,
) -> Result<GetDistributionMetricDataResult, RusotoError<GetDistributionMetricDataError>>;
async fn get_distributions(
&self,
input: GetDistributionsRequest,
) -> Result<GetDistributionsResult, RusotoError<GetDistributionsError>>;
async fn get_domain(
&self,
input: GetDomainRequest,
) -> Result<GetDomainResult, RusotoError<GetDomainError>>;
async fn get_domains(
&self,
input: GetDomainsRequest,
) -> Result<GetDomainsResult, RusotoError<GetDomainsError>>;
async fn get_export_snapshot_records(
&self,
input: GetExportSnapshotRecordsRequest,
) -> Result<GetExportSnapshotRecordsResult, RusotoError<GetExportSnapshotRecordsError>>;
async fn get_instance(
&self,
input: GetInstanceRequest,
) -> Result<GetInstanceResult, RusotoError<GetInstanceError>>;
async fn get_instance_access_details(
&self,
input: GetInstanceAccessDetailsRequest,
) -> Result<GetInstanceAccessDetailsResult, RusotoError<GetInstanceAccessDetailsError>>;
async fn get_instance_metric_data(
&self,
input: GetInstanceMetricDataRequest,
) -> Result<GetInstanceMetricDataResult, RusotoError<GetInstanceMetricDataError>>;
async fn get_instance_port_states(
&self,
input: GetInstancePortStatesRequest,
) -> Result<GetInstancePortStatesResult, RusotoError<GetInstancePortStatesError>>;
async fn get_instance_snapshot(
&self,
input: GetInstanceSnapshotRequest,
) -> Result<GetInstanceSnapshotResult, RusotoError<GetInstanceSnapshotError>>;
async fn get_instance_snapshots(
&self,
input: GetInstanceSnapshotsRequest,
) -> Result<GetInstanceSnapshotsResult, RusotoError<GetInstanceSnapshotsError>>;
async fn get_instance_state(
&self,
input: GetInstanceStateRequest,
) -> Result<GetInstanceStateResult, RusotoError<GetInstanceStateError>>;
async fn get_instances(
&self,
input: GetInstancesRequest,
) -> Result<GetInstancesResult, RusotoError<GetInstancesError>>;
async fn get_key_pair(
&self,
input: GetKeyPairRequest,
) -> Result<GetKeyPairResult, RusotoError<GetKeyPairError>>;
async fn get_key_pairs(
&self,
input: GetKeyPairsRequest,
) -> Result<GetKeyPairsResult, RusotoError<GetKeyPairsError>>;
async fn get_load_balancer(
&self,
input: GetLoadBalancerRequest,
) -> Result<GetLoadBalancerResult, RusotoError<GetLoadBalancerError>>;
async fn get_load_balancer_metric_data(
&self,
input: GetLoadBalancerMetricDataRequest,
) -> Result<GetLoadBalancerMetricDataResult, RusotoError<GetLoadBalancerMetricDataError>>;
async fn get_load_balancer_tls_certificates(
&self,
input: GetLoadBalancerTlsCertificatesRequest,
) -> Result<
GetLoadBalancerTlsCertificatesResult,
RusotoError<GetLoadBalancerTlsCertificatesError>,
>;
async fn get_load_balancers(
&self,
input: GetLoadBalancersRequest,
) -> Result<GetLoadBalancersResult, RusotoError<GetLoadBalancersError>>;
async fn get_operation(
&self,
input: GetOperationRequest,
) -> Result<GetOperationResult, RusotoError<GetOperationError>>;
async fn get_operations(
&self,
input: GetOperationsRequest,
) -> Result<GetOperationsResult, RusotoError<GetOperationsError>>;
async fn get_operations_for_resource(
&self,
input: GetOperationsForResourceRequest,
) -> Result<GetOperationsForResourceResult, RusotoError<GetOperationsForResourceError>>;
async fn get_regions(
&self,
input: GetRegionsRequest,
) -> Result<GetRegionsResult, RusotoError<GetRegionsError>>;
async fn get_relational_database(
&self,
input: GetRelationalDatabaseRequest,
) -> Result<GetRelationalDatabaseResult, RusotoError<GetRelationalDatabaseError>>;
async fn get_relational_database_blueprints(
&self,
input: GetRelationalDatabaseBlueprintsRequest,
) -> Result<
GetRelationalDatabaseBlueprintsResult,
RusotoError<GetRelationalDatabaseBlueprintsError>,
>;
async fn get_relational_database_bundles(
&self,
input: GetRelationalDatabaseBundlesRequest,
) -> Result<GetRelationalDatabaseBundlesResult, RusotoError<GetRelationalDatabaseBundlesError>>;
async fn get_relational_database_events(
&self,
input: GetRelationalDatabaseEventsRequest,
) -> Result<GetRelationalDatabaseEventsResult, RusotoError<GetRelationalDatabaseEventsError>>;
async fn get_relational_database_log_events(
&self,
input: GetRelationalDatabaseLogEventsRequest,
) -> Result<
GetRelationalDatabaseLogEventsResult,
RusotoError<GetRelationalDatabaseLogEventsError>,
>;
async fn get_relational_database_log_streams(
&self,
input: GetRelationalDatabaseLogStreamsRequest,
) -> Result<
GetRelationalDatabaseLogStreamsResult,
RusotoError<GetRelationalDatabaseLogStreamsError>,
>;
async fn get_relational_database_master_user_password(
&self,
input: GetRelationalDatabaseMasterUserPasswordRequest,
) -> Result<
GetRelationalDatabaseMasterUserPasswordResult,
RusotoError<GetRelationalDatabaseMasterUserPasswordError>,
>;
async fn get_relational_database_metric_data(
&self,
input: GetRelationalDatabaseMetricDataRequest,
) -> Result<
GetRelationalDatabaseMetricDataResult,
RusotoError<GetRelationalDatabaseMetricDataError>,
>;
async fn get_relational_database_parameters(
&self,
input: GetRelationalDatabaseParametersRequest,
) -> Result<
GetRelationalDatabaseParametersResult,
RusotoError<GetRelationalDatabaseParametersError>,
>;
async fn get_relational_database_snapshot(
&self,
input: GetRelationalDatabaseSnapshotRequest,
) -> Result<GetRelationalDatabaseSnapshotResult, RusotoError<GetRelationalDatabaseSnapshotError>>;
async fn get_relational_database_snapshots(
&self,
input: GetRelationalDatabaseSnapshotsRequest,
) -> Result<
GetRelationalDatabaseSnapshotsResult,
RusotoError<GetRelationalDatabaseSnapshotsError>,
>;
async fn get_relational_databases(
&self,
input: GetRelationalDatabasesRequest,
) -> Result<GetRelationalDatabasesResult, RusotoError<GetRelationalDatabasesError>>;
async fn get_static_ip(
&self,
input: GetStaticIpRequest,
) -> Result<GetStaticIpResult, RusotoError<GetStaticIpError>>;
async fn get_static_ips(
&self,
input: GetStaticIpsRequest,
) -> Result<GetStaticIpsResult, RusotoError<GetStaticIpsError>>;
async fn import_key_pair(
&self,
input: ImportKeyPairRequest,
) -> Result<ImportKeyPairResult, RusotoError<ImportKeyPairError>>;
async fn is_vpc_peered(&self) -> Result<IsVpcPeeredResult, RusotoError<IsVpcPeeredError>>;
async fn open_instance_public_ports(
&self,
input: OpenInstancePublicPortsRequest,
) -> Result<OpenInstancePublicPortsResult, RusotoError<OpenInstancePublicPortsError>>;
async fn peer_vpc(&self) -> Result<PeerVpcResult, RusotoError<PeerVpcError>>;
async fn put_alarm(
&self,
input: PutAlarmRequest,
) -> Result<PutAlarmResult, RusotoError<PutAlarmError>>;
async fn put_instance_public_ports(
&self,
input: PutInstancePublicPortsRequest,
) -> Result<PutInstancePublicPortsResult, RusotoError<PutInstancePublicPortsError>>;
async fn reboot_instance(
&self,
input: RebootInstanceRequest,
) -> Result<RebootInstanceResult, RusotoError<RebootInstanceError>>;
async fn reboot_relational_database(
&self,
input: RebootRelationalDatabaseRequest,
) -> Result<RebootRelationalDatabaseResult, RusotoError<RebootRelationalDatabaseError>>;
async fn register_container_image(
&self,
input: RegisterContainerImageRequest,
) -> Result<RegisterContainerImageResult, RusotoError<RegisterContainerImageError>>;
async fn release_static_ip(
&self,
input: ReleaseStaticIpRequest,
) -> Result<ReleaseStaticIpResult, RusotoError<ReleaseStaticIpError>>;
async fn reset_distribution_cache(
&self,
input: ResetDistributionCacheRequest,
) -> Result<ResetDistributionCacheResult, RusotoError<ResetDistributionCacheError>>;
async fn send_contact_method_verification(
&self,
input: SendContactMethodVerificationRequest,
) -> Result<SendContactMethodVerificationResult, RusotoError<SendContactMethodVerificationError>>;
async fn start_instance(
&self,
input: StartInstanceRequest,
) -> Result<StartInstanceResult, RusotoError<StartInstanceError>>;
async fn start_relational_database(
&self,
input: StartRelationalDatabaseRequest,
) -> Result<StartRelationalDatabaseResult, RusotoError<StartRelationalDatabaseError>>;
async fn stop_instance(
&self,
input: StopInstanceRequest,
) -> Result<StopInstanceResult, RusotoError<StopInstanceError>>;
async fn stop_relational_database(
&self,
input: StopRelationalDatabaseRequest,
) -> Result<StopRelationalDatabaseResult, RusotoError<StopRelationalDatabaseError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResult, RusotoError<TagResourceError>>;
async fn test_alarm(
&self,
input: TestAlarmRequest,
) -> Result<TestAlarmResult, RusotoError<TestAlarmError>>;
async fn unpeer_vpc(&self) -> Result<UnpeerVpcResult, RusotoError<UnpeerVpcError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResult, RusotoError<UntagResourceError>>;
async fn update_container_service(
&self,
input: UpdateContainerServiceRequest,
) -> Result<UpdateContainerServiceResult, RusotoError<UpdateContainerServiceError>>;
async fn update_distribution(
&self,
input: UpdateDistributionRequest,
) -> Result<UpdateDistributionResult, RusotoError<UpdateDistributionError>>;
async fn update_distribution_bundle(
&self,
input: UpdateDistributionBundleRequest,
) -> Result<UpdateDistributionBundleResult, RusotoError<UpdateDistributionBundleError>>;
async fn update_domain_entry(
&self,
input: UpdateDomainEntryRequest,
) -> Result<UpdateDomainEntryResult, RusotoError<UpdateDomainEntryError>>;
async fn update_load_balancer_attribute(
&self,
input: UpdateLoadBalancerAttributeRequest,
) -> Result<UpdateLoadBalancerAttributeResult, RusotoError<UpdateLoadBalancerAttributeError>>;
async fn update_relational_database(
&self,
input: UpdateRelationalDatabaseRequest,
) -> Result<UpdateRelationalDatabaseResult, RusotoError<UpdateRelationalDatabaseError>>;
async fn update_relational_database_parameters(
&self,
input: UpdateRelationalDatabaseParametersRequest,
) -> Result<
UpdateRelationalDatabaseParametersResult,
RusotoError<UpdateRelationalDatabaseParametersError>,
>;
}
#[derive(Clone)]
pub struct LightsailClient {
client: Client,
region: region::Region,
}
impl LightsailClient {
pub fn new(region: region::Region) -> LightsailClient {
LightsailClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> LightsailClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
LightsailClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> LightsailClient {
LightsailClient { client, region }
}
}
#[async_trait]
impl Lightsail for LightsailClient {
async fn allocate_static_ip(
&self,
input: AllocateStaticIpRequest,
) -> Result<AllocateStaticIpResult, RusotoError<AllocateStaticIpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.AllocateStaticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AllocateStaticIpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AllocateStaticIpResult, _>()
}
async fn attach_certificate_to_distribution(
&self,
input: AttachCertificateToDistributionRequest,
) -> Result<
AttachCertificateToDistributionResult,
RusotoError<AttachCertificateToDistributionError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.AttachCertificateToDistribution",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AttachCertificateToDistributionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AttachCertificateToDistributionResult, _>()
}
async fn attach_disk(
&self,
input: AttachDiskRequest,
) -> Result<AttachDiskResult, RusotoError<AttachDiskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.AttachDisk");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AttachDiskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AttachDiskResult, _>()
}
async fn attach_instances_to_load_balancer(
&self,
input: AttachInstancesToLoadBalancerRequest,
) -> Result<AttachInstancesToLoadBalancerResult, RusotoError<AttachInstancesToLoadBalancerError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.AttachInstancesToLoadBalancer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AttachInstancesToLoadBalancerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AttachInstancesToLoadBalancerResult, _>()
}
async fn attach_load_balancer_tls_certificate(
&self,
input: AttachLoadBalancerTlsCertificateRequest,
) -> Result<
AttachLoadBalancerTlsCertificateResult,
RusotoError<AttachLoadBalancerTlsCertificateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.AttachLoadBalancerTlsCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
AttachLoadBalancerTlsCertificateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AttachLoadBalancerTlsCertificateResult, _>()
}
async fn attach_static_ip(
&self,
input: AttachStaticIpRequest,
) -> Result<AttachStaticIpResult, RusotoError<AttachStaticIpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.AttachStaticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AttachStaticIpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AttachStaticIpResult, _>()
}
async fn close_instance_public_ports(
&self,
input: CloseInstancePublicPortsRequest,
) -> Result<CloseInstancePublicPortsResult, RusotoError<CloseInstancePublicPortsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CloseInstancePublicPorts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CloseInstancePublicPortsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CloseInstancePublicPortsResult, _>()
}
async fn copy_snapshot(
&self,
input: CopySnapshotRequest,
) -> Result<CopySnapshotResult, RusotoError<CopySnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CopySnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CopySnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CopySnapshotResult, _>()
}
async fn create_certificate(
&self,
input: CreateCertificateRequest,
) -> Result<CreateCertificateResult, RusotoError<CreateCertificateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateCertificate");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateCertificateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateCertificateResult, _>()
}
async fn create_cloud_formation_stack(
&self,
input: CreateCloudFormationStackRequest,
) -> Result<CreateCloudFormationStackResult, RusotoError<CreateCloudFormationStackError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateCloudFormationStack",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateCloudFormationStackError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCloudFormationStackResult, _>()
}
async fn create_contact_method(
&self,
input: CreateContactMethodRequest,
) -> Result<CreateContactMethodResult, RusotoError<CreateContactMethodError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateContactMethod");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateContactMethodError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateContactMethodResult, _>()
}
async fn create_container_service(
&self,
input: CreateContainerServiceRequest,
) -> Result<CreateContainerServiceResult, RusotoError<CreateContainerServiceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateContainerService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateContainerServiceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateContainerServiceResult, _>()
}
async fn create_container_service_deployment(
&self,
input: CreateContainerServiceDeploymentRequest,
) -> Result<
CreateContainerServiceDeploymentResult,
RusotoError<CreateContainerServiceDeploymentError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateContainerServiceDeployment",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateContainerServiceDeploymentError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateContainerServiceDeploymentResult, _>()
}
async fn create_container_service_registry_login(
&self,
) -> Result<
CreateContainerServiceRegistryLoginResult,
RusotoError<CreateContainerServiceRegistryLoginError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateContainerServiceRegistryLogin",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(
request,
CreateContainerServiceRegistryLoginError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateContainerServiceRegistryLoginResult, _>()
}
async fn create_disk(
&self,
input: CreateDiskRequest,
) -> Result<CreateDiskResult, RusotoError<CreateDiskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateDisk");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDiskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDiskResult, _>()
}
async fn create_disk_from_snapshot(
&self,
input: CreateDiskFromSnapshotRequest,
) -> Result<CreateDiskFromSnapshotResult, RusotoError<CreateDiskFromSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateDiskFromSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDiskFromSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDiskFromSnapshotResult, _>()
}
async fn create_disk_snapshot(
&self,
input: CreateDiskSnapshotRequest,
) -> Result<CreateDiskSnapshotResult, RusotoError<CreateDiskSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateDiskSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDiskSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDiskSnapshotResult, _>()
}
async fn create_distribution(
&self,
input: CreateDistributionRequest,
) -> Result<CreateDistributionResult, RusotoError<CreateDistributionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateDistribution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDistributionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDistributionResult, _>()
}
async fn create_domain(
&self,
input: CreateDomainRequest,
) -> Result<CreateDomainResult, RusotoError<CreateDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateDomain");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDomainResult, _>()
}
async fn create_domain_entry(
&self,
input: CreateDomainEntryRequest,
) -> Result<CreateDomainEntryResult, RusotoError<CreateDomainEntryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateDomainEntry");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDomainEntryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDomainEntryResult, _>()
}
async fn create_instance_snapshot(
&self,
input: CreateInstanceSnapshotRequest,
) -> Result<CreateInstanceSnapshotResult, RusotoError<CreateInstanceSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateInstanceSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateInstanceSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateInstanceSnapshotResult, _>()
}
async fn create_instances(
&self,
input: CreateInstancesRequest,
) -> Result<CreateInstancesResult, RusotoError<CreateInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateInstances");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateInstancesResult, _>()
}
async fn create_instances_from_snapshot(
&self,
input: CreateInstancesFromSnapshotRequest,
) -> Result<CreateInstancesFromSnapshotResult, RusotoError<CreateInstancesFromSnapshotError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateInstancesFromSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateInstancesFromSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateInstancesFromSnapshotResult, _>()
}
async fn create_key_pair(
&self,
input: CreateKeyPairRequest,
) -> Result<CreateKeyPairResult, RusotoError<CreateKeyPairError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateKeyPair");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateKeyPairError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateKeyPairResult, _>()
}
async fn create_load_balancer(
&self,
input: CreateLoadBalancerRequest,
) -> Result<CreateLoadBalancerResult, RusotoError<CreateLoadBalancerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.CreateLoadBalancer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLoadBalancerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLoadBalancerResult, _>()
}
async fn create_load_balancer_tls_certificate(
&self,
input: CreateLoadBalancerTlsCertificateRequest,
) -> Result<
CreateLoadBalancerTlsCertificateResult,
RusotoError<CreateLoadBalancerTlsCertificateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateLoadBalancerTlsCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateLoadBalancerTlsCertificateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLoadBalancerTlsCertificateResult, _>()
}
async fn create_relational_database(
&self,
input: CreateRelationalDatabaseRequest,
) -> Result<CreateRelationalDatabaseResult, RusotoError<CreateRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateRelationalDatabase",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRelationalDatabaseResult, _>()
}
async fn create_relational_database_from_snapshot(
&self,
input: CreateRelationalDatabaseFromSnapshotRequest,
) -> Result<
CreateRelationalDatabaseFromSnapshotResult,
RusotoError<CreateRelationalDatabaseFromSnapshotError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateRelationalDatabaseFromSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateRelationalDatabaseFromSnapshotError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRelationalDatabaseFromSnapshotResult, _>()
}
async fn create_relational_database_snapshot(
&self,
input: CreateRelationalDatabaseSnapshotRequest,
) -> Result<
CreateRelationalDatabaseSnapshotResult,
RusotoError<CreateRelationalDatabaseSnapshotError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.CreateRelationalDatabaseSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateRelationalDatabaseSnapshotError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRelationalDatabaseSnapshotResult, _>()
}
async fn delete_alarm(
&self,
input: DeleteAlarmRequest,
) -> Result<DeleteAlarmResult, RusotoError<DeleteAlarmError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteAlarm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAlarmError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteAlarmResult, _>()
}
async fn delete_auto_snapshot(
&self,
input: DeleteAutoSnapshotRequest,
) -> Result<DeleteAutoSnapshotResult, RusotoError<DeleteAutoSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteAutoSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAutoSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteAutoSnapshotResult, _>()
}
async fn delete_certificate(
&self,
input: DeleteCertificateRequest,
) -> Result<DeleteCertificateResult, RusotoError<DeleteCertificateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteCertificate");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteCertificateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteCertificateResult, _>()
}
async fn delete_contact_method(
&self,
input: DeleteContactMethodRequest,
) -> Result<DeleteContactMethodResult, RusotoError<DeleteContactMethodError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteContactMethod");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteContactMethodError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteContactMethodResult, _>()
}
async fn delete_container_image(
&self,
input: DeleteContainerImageRequest,
) -> Result<DeleteContainerImageResult, RusotoError<DeleteContainerImageError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteContainerImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteContainerImageError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteContainerImageResult, _>()
}
async fn delete_container_service(
&self,
input: DeleteContainerServiceRequest,
) -> Result<DeleteContainerServiceResult, RusotoError<DeleteContainerServiceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteContainerService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteContainerServiceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteContainerServiceResult, _>()
}
async fn delete_disk(
&self,
input: DeleteDiskRequest,
) -> Result<DeleteDiskResult, RusotoError<DeleteDiskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteDisk");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDiskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDiskResult, _>()
}
async fn delete_disk_snapshot(
&self,
input: DeleteDiskSnapshotRequest,
) -> Result<DeleteDiskSnapshotResult, RusotoError<DeleteDiskSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteDiskSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDiskSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDiskSnapshotResult, _>()
}
async fn delete_distribution(
&self,
input: DeleteDistributionRequest,
) -> Result<DeleteDistributionResult, RusotoError<DeleteDistributionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteDistribution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDistributionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDistributionResult, _>()
}
async fn delete_domain(
&self,
input: DeleteDomainRequest,
) -> Result<DeleteDomainResult, RusotoError<DeleteDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteDomain");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDomainResult, _>()
}
async fn delete_domain_entry(
&self,
input: DeleteDomainEntryRequest,
) -> Result<DeleteDomainEntryResult, RusotoError<DeleteDomainEntryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteDomainEntry");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDomainEntryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDomainEntryResult, _>()
}
async fn delete_instance(
&self,
input: DeleteInstanceRequest,
) -> Result<DeleteInstanceResult, RusotoError<DeleteInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteInstanceResult, _>()
}
async fn delete_instance_snapshot(
&self,
input: DeleteInstanceSnapshotRequest,
) -> Result<DeleteInstanceSnapshotResult, RusotoError<DeleteInstanceSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteInstanceSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteInstanceSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteInstanceSnapshotResult, _>()
}
async fn delete_key_pair(
&self,
input: DeleteKeyPairRequest,
) -> Result<DeleteKeyPairResult, RusotoError<DeleteKeyPairError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteKeyPair");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteKeyPairError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteKeyPairResult, _>()
}
async fn delete_known_host_keys(
&self,
input: DeleteKnownHostKeysRequest,
) -> Result<DeleteKnownHostKeysResult, RusotoError<DeleteKnownHostKeysError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteKnownHostKeys");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteKnownHostKeysError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteKnownHostKeysResult, _>()
}
async fn delete_load_balancer(
&self,
input: DeleteLoadBalancerRequest,
) -> Result<DeleteLoadBalancerResult, RusotoError<DeleteLoadBalancerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DeleteLoadBalancer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLoadBalancerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteLoadBalancerResult, _>()
}
async fn delete_load_balancer_tls_certificate(
&self,
input: DeleteLoadBalancerTlsCertificateRequest,
) -> Result<
DeleteLoadBalancerTlsCertificateResult,
RusotoError<DeleteLoadBalancerTlsCertificateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.DeleteLoadBalancerTlsCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteLoadBalancerTlsCertificateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteLoadBalancerTlsCertificateResult, _>()
}
async fn delete_relational_database(
&self,
input: DeleteRelationalDatabaseRequest,
) -> Result<DeleteRelationalDatabaseResult, RusotoError<DeleteRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.DeleteRelationalDatabase",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRelationalDatabaseResult, _>()
}
async fn delete_relational_database_snapshot(
&self,
input: DeleteRelationalDatabaseSnapshotRequest,
) -> Result<
DeleteRelationalDatabaseSnapshotResult,
RusotoError<DeleteRelationalDatabaseSnapshotError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.DeleteRelationalDatabaseSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteRelationalDatabaseSnapshotError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRelationalDatabaseSnapshotResult, _>()
}
async fn detach_certificate_from_distribution(
&self,
input: DetachCertificateFromDistributionRequest,
) -> Result<
DetachCertificateFromDistributionResult,
RusotoError<DetachCertificateFromDistributionError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.DetachCertificateFromDistribution",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DetachCertificateFromDistributionError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DetachCertificateFromDistributionResult, _>()
}
async fn detach_disk(
&self,
input: DetachDiskRequest,
) -> Result<DetachDiskResult, RusotoError<DetachDiskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DetachDisk");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DetachDiskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetachDiskResult, _>()
}
async fn detach_instances_from_load_balancer(
&self,
input: DetachInstancesFromLoadBalancerRequest,
) -> Result<
DetachInstancesFromLoadBalancerResult,
RusotoError<DetachInstancesFromLoadBalancerError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.DetachInstancesFromLoadBalancer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DetachInstancesFromLoadBalancerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DetachInstancesFromLoadBalancerResult, _>()
}
async fn detach_static_ip(
&self,
input: DetachStaticIpRequest,
) -> Result<DetachStaticIpResult, RusotoError<DetachStaticIpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DetachStaticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DetachStaticIpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetachStaticIpResult, _>()
}
async fn disable_add_on(
&self,
input: DisableAddOnRequest,
) -> Result<DisableAddOnResult, RusotoError<DisableAddOnError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DisableAddOn");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisableAddOnError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DisableAddOnResult, _>()
}
async fn download_default_key_pair(
&self,
) -> Result<DownloadDefaultKeyPairResult, RusotoError<DownloadDefaultKeyPairError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.DownloadDefaultKeyPair");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DownloadDefaultKeyPairError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DownloadDefaultKeyPairResult, _>()
}
async fn enable_add_on(
&self,
input: EnableAddOnRequest,
) -> Result<EnableAddOnResult, RusotoError<EnableAddOnError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.EnableAddOn");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, EnableAddOnError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<EnableAddOnResult, _>()
}
async fn export_snapshot(
&self,
input: ExportSnapshotRequest,
) -> Result<ExportSnapshotResult, RusotoError<ExportSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.ExportSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ExportSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ExportSnapshotResult, _>()
}
async fn get_active_names(
&self,
input: GetActiveNamesRequest,
) -> Result<GetActiveNamesResult, RusotoError<GetActiveNamesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetActiveNames");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetActiveNamesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetActiveNamesResult, _>()
}
async fn get_alarms(
&self,
input: GetAlarmsRequest,
) -> Result<GetAlarmsResult, RusotoError<GetAlarmsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetAlarms");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAlarmsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetAlarmsResult, _>()
}
async fn get_auto_snapshots(
&self,
input: GetAutoSnapshotsRequest,
) -> Result<GetAutoSnapshotsResult, RusotoError<GetAutoSnapshotsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetAutoSnapshots");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAutoSnapshotsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetAutoSnapshotsResult, _>()
}
async fn get_blueprints(
&self,
input: GetBlueprintsRequest,
) -> Result<GetBlueprintsResult, RusotoError<GetBlueprintsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetBlueprints");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetBlueprintsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetBlueprintsResult, _>()
}
async fn get_bundles(
&self,
input: GetBundlesRequest,
) -> Result<GetBundlesResult, RusotoError<GetBundlesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetBundles");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetBundlesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetBundlesResult, _>()
}
async fn get_certificates(
&self,
input: GetCertificatesRequest,
) -> Result<GetCertificatesResult, RusotoError<GetCertificatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetCertificates");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCertificatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetCertificatesResult, _>()
}
async fn get_cloud_formation_stack_records(
&self,
input: GetCloudFormationStackRecordsRequest,
) -> Result<GetCloudFormationStackRecordsResult, RusotoError<GetCloudFormationStackRecordsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetCloudFormationStackRecords",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCloudFormationStackRecordsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetCloudFormationStackRecordsResult, _>()
}
async fn get_contact_methods(
&self,
input: GetContactMethodsRequest,
) -> Result<GetContactMethodsResult, RusotoError<GetContactMethodsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetContactMethods");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetContactMethodsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetContactMethodsResult, _>()
}
async fn get_container_api_metadata(
&self,
) -> Result<GetContainerAPIMetadataResult, RusotoError<GetContainerAPIMetadataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetContainerAPIMetadata");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetContainerAPIMetadataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerAPIMetadataResult, _>()
}
async fn get_container_images(
&self,
input: GetContainerImagesRequest,
) -> Result<GetContainerImagesResult, RusotoError<GetContainerImagesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetContainerImages");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetContainerImagesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetContainerImagesResult, _>()
}
async fn get_container_log(
&self,
input: GetContainerLogRequest,
) -> Result<GetContainerLogResult, RusotoError<GetContainerLogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetContainerLog");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetContainerLogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetContainerLogResult, _>()
}
async fn get_container_service_deployments(
&self,
input: GetContainerServiceDeploymentsRequest,
) -> Result<
GetContainerServiceDeploymentsResult,
RusotoError<GetContainerServiceDeploymentsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetContainerServiceDeployments",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetContainerServiceDeploymentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerServiceDeploymentsResult, _>()
}
async fn get_container_service_metric_data(
&self,
input: GetContainerServiceMetricDataRequest,
) -> Result<GetContainerServiceMetricDataResult, RusotoError<GetContainerServiceMetricDataError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetContainerServiceMetricData",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetContainerServiceMetricDataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerServiceMetricDataResult, _>()
}
async fn get_container_service_powers(
&self,
) -> Result<GetContainerServicePowersResult, RusotoError<GetContainerServicePowersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetContainerServicePowers",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetContainerServicePowersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerServicePowersResult, _>()
}
async fn get_container_services(
&self,
input: GetContainerServicesRequest,
) -> Result<ContainerServicesListResult, RusotoError<GetContainerServicesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetContainerServices");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetContainerServicesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ContainerServicesListResult, _>()
}
async fn get_disk(
&self,
input: GetDiskRequest,
) -> Result<GetDiskResult, RusotoError<GetDiskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDisk");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDiskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDiskResult, _>()
}
async fn get_disk_snapshot(
&self,
input: GetDiskSnapshotRequest,
) -> Result<GetDiskSnapshotResult, RusotoError<GetDiskSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDiskSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDiskSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDiskSnapshotResult, _>()
}
async fn get_disk_snapshots(
&self,
input: GetDiskSnapshotsRequest,
) -> Result<GetDiskSnapshotsResult, RusotoError<GetDiskSnapshotsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDiskSnapshots");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDiskSnapshotsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDiskSnapshotsResult, _>()
}
async fn get_disks(
&self,
input: GetDisksRequest,
) -> Result<GetDisksResult, RusotoError<GetDisksError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDisks");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDisksError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDisksResult, _>()
}
async fn get_distribution_bundles(
&self,
) -> Result<GetDistributionBundlesResult, RusotoError<GetDistributionBundlesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDistributionBundles");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetDistributionBundlesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetDistributionBundlesResult, _>()
}
async fn get_distribution_latest_cache_reset(
&self,
input: GetDistributionLatestCacheResetRequest,
) -> Result<
GetDistributionLatestCacheResetResult,
RusotoError<GetDistributionLatestCacheResetError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetDistributionLatestCacheReset",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDistributionLatestCacheResetError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetDistributionLatestCacheResetResult, _>()
}
async fn get_distribution_metric_data(
&self,
input: GetDistributionMetricDataRequest,
) -> Result<GetDistributionMetricDataResult, RusotoError<GetDistributionMetricDataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetDistributionMetricData",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDistributionMetricDataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetDistributionMetricDataResult, _>()
}
async fn get_distributions(
&self,
input: GetDistributionsRequest,
) -> Result<GetDistributionsResult, RusotoError<GetDistributionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDistributions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDistributionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDistributionsResult, _>()
}
async fn get_domain(
&self,
input: GetDomainRequest,
) -> Result<GetDomainResult, RusotoError<GetDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDomain");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDomainResult, _>()
}
async fn get_domains(
&self,
input: GetDomainsRequest,
) -> Result<GetDomainsResult, RusotoError<GetDomainsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetDomains");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDomainsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDomainsResult, _>()
}
async fn get_export_snapshot_records(
&self,
input: GetExportSnapshotRecordsRequest,
) -> Result<GetExportSnapshotRecordsResult, RusotoError<GetExportSnapshotRecordsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetExportSnapshotRecords",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetExportSnapshotRecordsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetExportSnapshotRecordsResult, _>()
}
async fn get_instance(
&self,
input: GetInstanceRequest,
) -> Result<GetInstanceResult, RusotoError<GetInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstanceResult, _>()
}
async fn get_instance_access_details(
&self,
input: GetInstanceAccessDetailsRequest,
) -> Result<GetInstanceAccessDetailsResult, RusotoError<GetInstanceAccessDetailsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetInstanceAccessDetails",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceAccessDetailsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetInstanceAccessDetailsResult, _>()
}
async fn get_instance_metric_data(
&self,
input: GetInstanceMetricDataRequest,
) -> Result<GetInstanceMetricDataResult, RusotoError<GetInstanceMetricDataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstanceMetricData");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceMetricDataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstanceMetricDataResult, _>()
}
async fn get_instance_port_states(
&self,
input: GetInstancePortStatesRequest,
) -> Result<GetInstancePortStatesResult, RusotoError<GetInstancePortStatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstancePortStates");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstancePortStatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstancePortStatesResult, _>()
}
async fn get_instance_snapshot(
&self,
input: GetInstanceSnapshotRequest,
) -> Result<GetInstanceSnapshotResult, RusotoError<GetInstanceSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstanceSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstanceSnapshotResult, _>()
}
async fn get_instance_snapshots(
&self,
input: GetInstanceSnapshotsRequest,
) -> Result<GetInstanceSnapshotsResult, RusotoError<GetInstanceSnapshotsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstanceSnapshots");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceSnapshotsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstanceSnapshotsResult, _>()
}
async fn get_instance_state(
&self,
input: GetInstanceStateRequest,
) -> Result<GetInstanceStateResult, RusotoError<GetInstanceStateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstanceState");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstanceStateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstanceStateResult, _>()
}
async fn get_instances(
&self,
input: GetInstancesRequest,
) -> Result<GetInstancesResult, RusotoError<GetInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetInstances");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetInstancesResult, _>()
}
async fn get_key_pair(
&self,
input: GetKeyPairRequest,
) -> Result<GetKeyPairResult, RusotoError<GetKeyPairError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetKeyPair");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetKeyPairError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetKeyPairResult, _>()
}
async fn get_key_pairs(
&self,
input: GetKeyPairsRequest,
) -> Result<GetKeyPairsResult, RusotoError<GetKeyPairsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetKeyPairs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetKeyPairsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetKeyPairsResult, _>()
}
async fn get_load_balancer(
&self,
input: GetLoadBalancerRequest,
) -> Result<GetLoadBalancerResult, RusotoError<GetLoadBalancerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetLoadBalancer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLoadBalancerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetLoadBalancerResult, _>()
}
async fn get_load_balancer_metric_data(
&self,
input: GetLoadBalancerMetricDataRequest,
) -> Result<GetLoadBalancerMetricDataResult, RusotoError<GetLoadBalancerMetricDataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetLoadBalancerMetricData",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLoadBalancerMetricDataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetLoadBalancerMetricDataResult, _>()
}
async fn get_load_balancer_tls_certificates(
&self,
input: GetLoadBalancerTlsCertificatesRequest,
) -> Result<
GetLoadBalancerTlsCertificatesResult,
RusotoError<GetLoadBalancerTlsCertificatesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetLoadBalancerTlsCertificates",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLoadBalancerTlsCertificatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetLoadBalancerTlsCertificatesResult, _>()
}
async fn get_load_balancers(
&self,
input: GetLoadBalancersRequest,
) -> Result<GetLoadBalancersResult, RusotoError<GetLoadBalancersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetLoadBalancers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLoadBalancersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetLoadBalancersResult, _>()
}
async fn get_operation(
&self,
input: GetOperationRequest,
) -> Result<GetOperationResult, RusotoError<GetOperationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetOperation");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetOperationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetOperationResult, _>()
}
async fn get_operations(
&self,
input: GetOperationsRequest,
) -> Result<GetOperationsResult, RusotoError<GetOperationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetOperations");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetOperationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetOperationsResult, _>()
}
async fn get_operations_for_resource(
&self,
input: GetOperationsForResourceRequest,
) -> Result<GetOperationsForResourceResult, RusotoError<GetOperationsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetOperationsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetOperationsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetOperationsForResourceResult, _>()
}
async fn get_regions(
&self,
input: GetRegionsRequest,
) -> Result<GetRegionsResult, RusotoError<GetRegionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetRegions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRegionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetRegionsResult, _>()
}
async fn get_relational_database(
&self,
input: GetRelationalDatabaseRequest,
) -> Result<GetRelationalDatabaseResult, RusotoError<GetRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetRelationalDatabase");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetRelationalDatabaseResult, _>()
}
async fn get_relational_database_blueprints(
&self,
input: GetRelationalDatabaseBlueprintsRequest,
) -> Result<
GetRelationalDatabaseBlueprintsResult,
RusotoError<GetRelationalDatabaseBlueprintsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseBlueprints",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseBlueprintsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseBlueprintsResult, _>()
}
async fn get_relational_database_bundles(
&self,
input: GetRelationalDatabaseBundlesRequest,
) -> Result<GetRelationalDatabaseBundlesResult, RusotoError<GetRelationalDatabaseBundlesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseBundles",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseBundlesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseBundlesResult, _>()
}
async fn get_relational_database_events(
&self,
input: GetRelationalDatabaseEventsRequest,
) -> Result<GetRelationalDatabaseEventsResult, RusotoError<GetRelationalDatabaseEventsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseEvents",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseEventsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseEventsResult, _>()
}
async fn get_relational_database_log_events(
&self,
input: GetRelationalDatabaseLogEventsRequest,
) -> Result<
GetRelationalDatabaseLogEventsResult,
RusotoError<GetRelationalDatabaseLogEventsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseLogEvents",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseLogEventsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseLogEventsResult, _>()
}
async fn get_relational_database_log_streams(
&self,
input: GetRelationalDatabaseLogStreamsRequest,
) -> Result<
GetRelationalDatabaseLogStreamsResult,
RusotoError<GetRelationalDatabaseLogStreamsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseLogStreams",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseLogStreamsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseLogStreamsResult, _>()
}
async fn get_relational_database_master_user_password(
&self,
input: GetRelationalDatabaseMasterUserPasswordRequest,
) -> Result<
GetRelationalDatabaseMasterUserPasswordResult,
RusotoError<GetRelationalDatabaseMasterUserPasswordError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseMasterUserPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetRelationalDatabaseMasterUserPasswordError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseMasterUserPasswordResult, _>()
}
async fn get_relational_database_metric_data(
&self,
input: GetRelationalDatabaseMetricDataRequest,
) -> Result<
GetRelationalDatabaseMetricDataResult,
RusotoError<GetRelationalDatabaseMetricDataError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseMetricData",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseMetricDataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseMetricDataResult, _>()
}
async fn get_relational_database_parameters(
&self,
input: GetRelationalDatabaseParametersRequest,
) -> Result<
GetRelationalDatabaseParametersResult,
RusotoError<GetRelationalDatabaseParametersError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseParameters",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseParametersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseParametersResult, _>()
}
async fn get_relational_database_snapshot(
&self,
input: GetRelationalDatabaseSnapshotRequest,
) -> Result<GetRelationalDatabaseSnapshotResult, RusotoError<GetRelationalDatabaseSnapshotError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseSnapshotResult, _>()
}
async fn get_relational_database_snapshots(
&self,
input: GetRelationalDatabaseSnapshotsRequest,
) -> Result<
GetRelationalDatabaseSnapshotsResult,
RusotoError<GetRelationalDatabaseSnapshotsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.GetRelationalDatabaseSnapshots",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabaseSnapshotsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabaseSnapshotsResult, _>()
}
async fn get_relational_databases(
&self,
input: GetRelationalDatabasesRequest,
) -> Result<GetRelationalDatabasesResult, RusotoError<GetRelationalDatabasesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetRelationalDatabases");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRelationalDatabasesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRelationalDatabasesResult, _>()
}
async fn get_static_ip(
&self,
input: GetStaticIpRequest,
) -> Result<GetStaticIpResult, RusotoError<GetStaticIpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetStaticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetStaticIpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetStaticIpResult, _>()
}
async fn get_static_ips(
&self,
input: GetStaticIpsRequest,
) -> Result<GetStaticIpsResult, RusotoError<GetStaticIpsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.GetStaticIps");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetStaticIpsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetStaticIpsResult, _>()
}
async fn import_key_pair(
&self,
input: ImportKeyPairRequest,
) -> Result<ImportKeyPairResult, RusotoError<ImportKeyPairError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.ImportKeyPair");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ImportKeyPairError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ImportKeyPairResult, _>()
}
async fn is_vpc_peered(&self) -> Result<IsVpcPeeredResult, RusotoError<IsVpcPeeredError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.IsVpcPeered");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, IsVpcPeeredError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<IsVpcPeeredResult, _>()
}
async fn open_instance_public_ports(
&self,
input: OpenInstancePublicPortsRequest,
) -> Result<OpenInstancePublicPortsResult, RusotoError<OpenInstancePublicPortsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.OpenInstancePublicPorts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, OpenInstancePublicPortsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<OpenInstancePublicPortsResult, _>()
}
async fn peer_vpc(&self) -> Result<PeerVpcResult, RusotoError<PeerVpcError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.PeerVpc");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, PeerVpcError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PeerVpcResult, _>()
}
async fn put_alarm(
&self,
input: PutAlarmRequest,
) -> Result<PutAlarmResult, RusotoError<PutAlarmError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.PutAlarm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutAlarmError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutAlarmResult, _>()
}
async fn put_instance_public_ports(
&self,
input: PutInstancePublicPortsRequest,
) -> Result<PutInstancePublicPortsResult, RusotoError<PutInstancePublicPortsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.PutInstancePublicPorts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutInstancePublicPortsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutInstancePublicPortsResult, _>()
}
async fn reboot_instance(
&self,
input: RebootInstanceRequest,
) -> Result<RebootInstanceResult, RusotoError<RebootInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.RebootInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RebootInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RebootInstanceResult, _>()
}
async fn reboot_relational_database(
&self,
input: RebootRelationalDatabaseRequest,
) -> Result<RebootRelationalDatabaseResult, RusotoError<RebootRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.RebootRelationalDatabase",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RebootRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RebootRelationalDatabaseResult, _>()
}
async fn register_container_image(
&self,
input: RegisterContainerImageRequest,
) -> Result<RegisterContainerImageResult, RusotoError<RegisterContainerImageError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.RegisterContainerImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterContainerImageError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RegisterContainerImageResult, _>()
}
async fn release_static_ip(
&self,
input: ReleaseStaticIpRequest,
) -> Result<ReleaseStaticIpResult, RusotoError<ReleaseStaticIpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.ReleaseStaticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ReleaseStaticIpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ReleaseStaticIpResult, _>()
}
async fn reset_distribution_cache(
&self,
input: ResetDistributionCacheRequest,
) -> Result<ResetDistributionCacheResult, RusotoError<ResetDistributionCacheError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.ResetDistributionCache");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ResetDistributionCacheError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ResetDistributionCacheResult, _>()
}
async fn send_contact_method_verification(
&self,
input: SendContactMethodVerificationRequest,
) -> Result<SendContactMethodVerificationResult, RusotoError<SendContactMethodVerificationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.SendContactMethodVerification",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SendContactMethodVerificationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SendContactMethodVerificationResult, _>()
}
async fn start_instance(
&self,
input: StartInstanceRequest,
) -> Result<StartInstanceResult, RusotoError<StartInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.StartInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartInstanceResult, _>()
}
async fn start_relational_database(
&self,
input: StartRelationalDatabaseRequest,
) -> Result<StartRelationalDatabaseResult, RusotoError<StartRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.StartRelationalDatabase");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartRelationalDatabaseResult, _>()
}
async fn stop_instance(
&self,
input: StopInstanceRequest,
) -> Result<StopInstanceResult, RusotoError<StopInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.StopInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopInstanceResult, _>()
}
async fn stop_relational_database(
&self,
input: StopRelationalDatabaseRequest,
) -> Result<StopRelationalDatabaseResult, RusotoError<StopRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.StopRelationalDatabase");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopRelationalDatabaseResult, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResult, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.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::<TagResourceResult, _>()
}
async fn test_alarm(
&self,
input: TestAlarmRequest,
) -> Result<TestAlarmResult, RusotoError<TestAlarmError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.TestAlarm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TestAlarmError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TestAlarmResult, _>()
}
async fn unpeer_vpc(&self) -> Result<UnpeerVpcResult, RusotoError<UnpeerVpcError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.UnpeerVpc");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, UnpeerVpcError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UnpeerVpcResult, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResult, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.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::<UntagResourceResult, _>()
}
async fn update_container_service(
&self,
input: UpdateContainerServiceRequest,
) -> Result<UpdateContainerServiceResult, RusotoError<UpdateContainerServiceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.UpdateContainerService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateContainerServiceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateContainerServiceResult, _>()
}
async fn update_distribution(
&self,
input: UpdateDistributionRequest,
) -> Result<UpdateDistributionResult, RusotoError<UpdateDistributionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.UpdateDistribution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDistributionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDistributionResult, _>()
}
async fn update_distribution_bundle(
&self,
input: UpdateDistributionBundleRequest,
) -> Result<UpdateDistributionBundleResult, RusotoError<UpdateDistributionBundleError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.UpdateDistributionBundle",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDistributionBundleError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDistributionBundleResult, _>()
}
async fn update_domain_entry(
&self,
input: UpdateDomainEntryRequest,
) -> Result<UpdateDomainEntryResult, RusotoError<UpdateDomainEntryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "Lightsail_20161128.UpdateDomainEntry");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDomainEntryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDomainEntryResult, _>()
}
async fn update_load_balancer_attribute(
&self,
input: UpdateLoadBalancerAttributeRequest,
) -> Result<UpdateLoadBalancerAttributeResult, RusotoError<UpdateLoadBalancerAttributeError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.UpdateLoadBalancerAttribute",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateLoadBalancerAttributeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateLoadBalancerAttributeResult, _>()
}
async fn update_relational_database(
&self,
input: UpdateRelationalDatabaseRequest,
) -> Result<UpdateRelationalDatabaseResult, RusotoError<UpdateRelationalDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.UpdateRelationalDatabase",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateRelationalDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRelationalDatabaseResult, _>()
}
async fn update_relational_database_parameters(
&self,
input: UpdateRelationalDatabaseParametersRequest,
) -> Result<
UpdateRelationalDatabaseParametersResult,
RusotoError<UpdateRelationalDatabaseParametersError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"Lightsail_20161128.UpdateRelationalDatabaseParameters",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateRelationalDatabaseParametersError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRelationalDatabaseParametersResult, _>()
}
}