use std::error::Error;
use std::fmt;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError, RusotoFuture};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto::xml::error::*;
use rusoto_core::proto::xml::util::{
characters, deserialize_elements, end_element, find_start_element, peek_at_name, skip_tree,
start_element,
};
use rusoto_core::proto::xml::util::{Next, Peek, XmlParseError, XmlResponse};
use rusoto_core::signature::SignedRequest;
use serde_urlencoded;
use std::str::FromStr;
use xml::reader::ParserConfig;
use xml::EventReader;
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptReservedInstancesExchangeQuoteRequest {
pub dry_run: Option<bool>,
pub reserved_instance_ids: Vec<String>,
pub target_configurations: Option<Vec<TargetConfigurationRequest>>,
}
struct AcceptReservedInstancesExchangeQuoteRequestSerializer;
impl AcceptReservedInstancesExchangeQuoteRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &AcceptReservedInstancesExchangeQuoteRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ReservedInstanceIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstanceId"),
&obj.reserved_instance_ids,
);
if let Some(ref field_value) = obj.target_configurations {
TargetConfigurationRequestSetSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetConfiguration"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptReservedInstancesExchangeQuoteResult {
pub exchange_id: Option<String>,
}
struct AcceptReservedInstancesExchangeQuoteResultDeserializer;
impl AcceptReservedInstancesExchangeQuoteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AcceptReservedInstancesExchangeQuoteResult, XmlParseError> {
deserialize_elements::<_, AcceptReservedInstancesExchangeQuoteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"exchangeId" => {
obj.exchange_id =
Some(StringDeserializer::deserialize("exchangeId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptTransitGatewayVpcAttachmentRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
}
struct AcceptTransitGatewayVpcAttachmentRequestSerializer;
impl AcceptTransitGatewayVpcAttachmentRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AcceptTransitGatewayVpcAttachmentRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptTransitGatewayVpcAttachmentResult {
pub transit_gateway_vpc_attachment: Option<TransitGatewayVpcAttachment>,
}
struct AcceptTransitGatewayVpcAttachmentResultDeserializer;
impl AcceptTransitGatewayVpcAttachmentResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AcceptTransitGatewayVpcAttachmentResult, XmlParseError> {
deserialize_elements::<_, AcceptTransitGatewayVpcAttachmentResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayVpcAttachment" => {
obj.transit_gateway_vpc_attachment =
Some(TransitGatewayVpcAttachmentDeserializer::deserialize(
"transitGatewayVpcAttachment",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptVpcEndpointConnectionsRequest {
pub dry_run: Option<bool>,
pub service_id: String,
pub vpc_endpoint_ids: Vec<String>,
}
struct AcceptVpcEndpointConnectionsRequestSerializer;
impl AcceptVpcEndpointConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AcceptVpcEndpointConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "ServiceId"), &obj.service_id);
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcEndpointId"),
&obj.vpc_endpoint_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptVpcEndpointConnectionsResult {
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct AcceptVpcEndpointConnectionsResultDeserializer;
impl AcceptVpcEndpointConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AcceptVpcEndpointConnectionsResult, XmlParseError> {
deserialize_elements::<_, AcceptVpcEndpointConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptVpcPeeringConnectionRequest {
pub dry_run: Option<bool>,
pub vpc_peering_connection_id: Option<String>,
}
struct AcceptVpcPeeringConnectionRequestSerializer;
impl AcceptVpcPeeringConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AcceptVpcPeeringConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.vpc_peering_connection_id {
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AcceptVpcPeeringConnectionResult {
pub vpc_peering_connection: Option<VpcPeeringConnection>,
}
struct AcceptVpcPeeringConnectionResultDeserializer;
impl AcceptVpcPeeringConnectionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AcceptVpcPeeringConnectionResult, XmlParseError> {
deserialize_elements::<_, AcceptVpcPeeringConnectionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpcPeeringConnection" => {
obj.vpc_peering_connection =
Some(VpcPeeringConnectionDeserializer::deserialize(
"vpcPeeringConnection",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AccountAttribute {
pub attribute_name: Option<String>,
pub attribute_values: Option<Vec<AccountAttributeValue>>,
}
struct AccountAttributeDeserializer;
impl AccountAttributeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountAttribute, XmlParseError> {
deserialize_elements::<_, AccountAttribute, _>(tag_name, stack, |name, stack, obj| {
match name {
"attributeName" => {
obj.attribute_name =
Some(StringDeserializer::deserialize("attributeName", stack)?);
}
"attributeValueSet" => {
obj.attribute_values.get_or_insert(vec![]).extend(
AccountAttributeValueListDeserializer::deserialize(
"attributeValueSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AccountAttributeListDeserializer;
impl AccountAttributeListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AccountAttribute>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AccountAttributeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct AccountAttributeNameStringListSerializer;
impl AccountAttributeNameStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AccountAttributeValue {
pub attribute_value: Option<String>,
}
struct AccountAttributeValueDeserializer;
impl AccountAttributeValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountAttributeValue, XmlParseError> {
deserialize_elements::<_, AccountAttributeValue, _>(tag_name, stack, |name, stack, obj| {
match name {
"attributeValue" => {
obj.attribute_value =
Some(StringDeserializer::deserialize("attributeValue", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AccountAttributeValueListDeserializer;
impl AccountAttributeValueListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AccountAttributeValue>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AccountAttributeValueDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ActiveInstance {
pub instance_health: Option<String>,
pub instance_id: Option<String>,
pub instance_type: Option<String>,
pub spot_instance_request_id: Option<String>,
}
struct ActiveInstanceDeserializer;
impl ActiveInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ActiveInstance, XmlParseError> {
deserialize_elements::<_, ActiveInstance, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceHealth" => {
obj.instance_health = Some(InstanceHealthStatusDeserializer::deserialize(
"instanceHealth",
stack,
)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
"spotInstanceRequestId" => {
obj.spot_instance_request_id = Some(StringDeserializer::deserialize(
"spotInstanceRequestId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ActiveInstanceSetDeserializer;
impl ActiveInstanceSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ActiveInstance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ActiveInstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ActivityStatusDeserializer;
impl ActivityStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Address {
pub allocation_id: Option<String>,
pub association_id: Option<String>,
pub domain: Option<String>,
pub instance_id: Option<String>,
pub network_interface_id: Option<String>,
pub network_interface_owner_id: Option<String>,
pub private_ip_address: Option<String>,
pub public_ip: Option<String>,
pub public_ipv_4_pool: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct AddressDeserializer;
impl AddressDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Address, XmlParseError> {
deserialize_elements::<_, Address, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationId" => {
obj.allocation_id =
Some(StringDeserializer::deserialize("allocationId", stack)?);
}
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"domain" => {
obj.domain = Some(DomainTypeDeserializer::deserialize("domain", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"networkInterfaceOwnerId" => {
obj.network_interface_owner_id = Some(StringDeserializer::deserialize(
"networkInterfaceOwnerId",
stack,
)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
"publicIpv4Pool" => {
obj.public_ipv_4_pool =
Some(StringDeserializer::deserialize("publicIpv4Pool", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AddressListDeserializer;
impl AddressListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Address>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AddressDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AdvertiseByoipCidrRequest {
pub cidr: String,
pub dry_run: Option<bool>,
}
struct AdvertiseByoipCidrRequestSerializer;
impl AdvertiseByoipCidrRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AdvertiseByoipCidrRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Cidr"), &obj.cidr);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AdvertiseByoipCidrResult {
pub byoip_cidr: Option<ByoipCidr>,
}
struct AdvertiseByoipCidrResultDeserializer;
impl AdvertiseByoipCidrResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AdvertiseByoipCidrResult, XmlParseError> {
deserialize_elements::<_, AdvertiseByoipCidrResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"byoipCidr" => {
obj.byoip_cidr =
Some(ByoipCidrDeserializer::deserialize("byoipCidr", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AllocateAddressRequest {
pub address: Option<String>,
pub domain: Option<String>,
pub dry_run: Option<bool>,
pub public_ipv_4_pool: Option<String>,
}
struct AllocateAddressRequestSerializer;
impl AllocateAddressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AllocateAddressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.address {
params.put(&format!("{}{}", prefix, "Address"), &field_value);
}
if let Some(ref field_value) = obj.domain {
params.put(&format!("{}{}", prefix, "Domain"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.public_ipv_4_pool {
params.put(&format!("{}{}", prefix, "PublicIpv4Pool"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AllocateAddressResult {
pub allocation_id: Option<String>,
pub domain: Option<String>,
pub public_ip: Option<String>,
pub public_ipv_4_pool: Option<String>,
}
struct AllocateAddressResultDeserializer;
impl AllocateAddressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AllocateAddressResult, XmlParseError> {
deserialize_elements::<_, AllocateAddressResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationId" => {
obj.allocation_id =
Some(StringDeserializer::deserialize("allocationId", stack)?);
}
"domain" => {
obj.domain = Some(DomainTypeDeserializer::deserialize("domain", stack)?);
}
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
"publicIpv4Pool" => {
obj.public_ipv_4_pool =
Some(StringDeserializer::deserialize("publicIpv4Pool", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AllocateHostsRequest {
pub auto_placement: Option<String>,
pub availability_zone: String,
pub client_token: Option<String>,
pub host_recovery: Option<String>,
pub instance_type: String,
pub quantity: i64,
pub tag_specifications: Option<Vec<TagSpecification>>,
}
struct AllocateHostsRequestSerializer;
impl AllocateHostsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AllocateHostsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_placement {
params.put(&format!("{}{}", prefix, "AutoPlacement"), &field_value);
}
params.put(
&format!("{}{}", prefix, "AvailabilityZone"),
&obj.availability_zone,
);
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.host_recovery {
params.put(&format!("{}{}", prefix, "HostRecovery"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceType"), &obj.instance_type);
params.put(&format!("{}{}", prefix, "Quantity"), &obj.quantity);
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AllocateHostsResult {
pub host_ids: Option<Vec<String>>,
}
struct AllocateHostsResultDeserializer;
impl AllocateHostsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AllocateHostsResult, XmlParseError> {
deserialize_elements::<_, AllocateHostsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"hostIdSet" => {
obj.host_ids.get_or_insert(vec![]).extend(
ResponseHostIdListDeserializer::deserialize("hostIdSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AllocationIdListSerializer;
impl AllocationIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct AllocationStateDeserializer;
impl AllocationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AllocationStrategyDeserializer;
impl AllocationStrategyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AllowedPrincipal {
pub principal: Option<String>,
pub principal_type: Option<String>,
}
struct AllowedPrincipalDeserializer;
impl AllowedPrincipalDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AllowedPrincipal, XmlParseError> {
deserialize_elements::<_, AllowedPrincipal, _>(tag_name, stack, |name, stack, obj| {
match name {
"principal" => {
obj.principal = Some(StringDeserializer::deserialize("principal", stack)?);
}
"principalType" => {
obj.principal_type = Some(PrincipalTypeDeserializer::deserialize(
"principalType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AllowedPrincipalSetDeserializer;
impl AllowedPrincipalSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AllowedPrincipal>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AllowedPrincipalDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ApplySecurityGroupsToClientVpnTargetNetworkRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub security_group_ids: Vec<String>,
pub vpc_id: String,
}
struct ApplySecurityGroupsToClientVpnTargetNetworkRequestSerializer;
impl ApplySecurityGroupsToClientVpnTargetNetworkRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ApplySecurityGroupsToClientVpnTargetNetworkRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ClientVpnSecurityGroupIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
&obj.security_group_ids,
);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ApplySecurityGroupsToClientVpnTargetNetworkResult {
pub security_group_ids: Option<Vec<String>>,
}
struct ApplySecurityGroupsToClientVpnTargetNetworkResultDeserializer;
impl ApplySecurityGroupsToClientVpnTargetNetworkResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ApplySecurityGroupsToClientVpnTargetNetworkResult, XmlParseError> {
deserialize_elements::<_, ApplySecurityGroupsToClientVpnTargetNetworkResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"securityGroupIds" => {
obj.security_group_ids.get_or_insert(vec![]).extend(
ClientVpnSecurityGroupIdSetDeserializer::deserialize(
"securityGroupIds",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ArchitectureValuesDeserializer;
impl ArchitectureValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssignIpv6AddressesRequest {
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<String>>,
pub network_interface_id: String,
}
struct AssignIpv6AddressesRequestSerializer;
impl AssignIpv6AddressesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssignIpv6AddressesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.ipv_6_address_count {
params.put(&format!("{}{}", prefix, "Ipv6AddressCount"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_addresses {
Ipv6AddressListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Addresses"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssignIpv6AddressesResult {
pub assigned_ipv_6_addresses: Option<Vec<String>>,
pub network_interface_id: Option<String>,
}
struct AssignIpv6AddressesResultDeserializer;
impl AssignIpv6AddressesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssignIpv6AddressesResult, XmlParseError> {
deserialize_elements::<_, AssignIpv6AddressesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"assignedIpv6Addresses" => {
obj.assigned_ipv_6_addresses.get_or_insert(vec![]).extend(
Ipv6AddressListDeserializer::deserialize(
"assignedIpv6Addresses",
stack,
)?,
);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssignPrivateIpAddressesRequest {
pub allow_reassignment: Option<bool>,
pub network_interface_id: String,
pub private_ip_addresses: Option<Vec<String>>,
pub secondary_private_ip_address_count: Option<i64>,
}
struct AssignPrivateIpAddressesRequestSerializer;
impl AssignPrivateIpAddressesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssignPrivateIpAddressesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allow_reassignment {
params.put(&format!("{}{}", prefix, "AllowReassignment"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
if let Some(ref field_value) = obj.private_ip_addresses {
PrivateIpAddressStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrivateIpAddress"),
field_value,
);
}
if let Some(ref field_value) = obj.secondary_private_ip_address_count {
params.put(
&format!("{}{}", prefix, "SecondaryPrivateIpAddressCount"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateAddressRequest {
pub allocation_id: Option<String>,
pub allow_reassociation: Option<bool>,
pub dry_run: Option<bool>,
pub instance_id: Option<String>,
pub network_interface_id: Option<String>,
pub private_ip_address: Option<String>,
pub public_ip: Option<String>,
}
struct AssociateAddressRequestSerializer;
impl AssociateAddressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateAddressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocation_id {
params.put(&format!("{}{}", prefix, "AllocationId"), &field_value);
}
if let Some(ref field_value) = obj.allow_reassociation {
params.put(&format!("{}{}", prefix, "AllowReassociation"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
if let Some(ref field_value) = obj.network_interface_id {
params.put(&format!("{}{}", prefix, "NetworkInterfaceId"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.public_ip {
params.put(&format!("{}{}", prefix, "PublicIp"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateAddressResult {
pub association_id: Option<String>,
}
struct AssociateAddressResultDeserializer;
impl AssociateAddressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateAddressResult, XmlParseError> {
deserialize_elements::<_, AssociateAddressResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateClientVpnTargetNetworkRequest {
pub client_token: Option<String>,
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub subnet_id: String,
}
struct AssociateClientVpnTargetNetworkRequestSerializer;
impl AssociateClientVpnTargetNetworkRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateClientVpnTargetNetworkRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateClientVpnTargetNetworkResult {
pub association_id: Option<String>,
pub status: Option<AssociationStatus>,
}
struct AssociateClientVpnTargetNetworkResultDeserializer;
impl AssociateClientVpnTargetNetworkResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateClientVpnTargetNetworkResult, XmlParseError> {
deserialize_elements::<_, AssociateClientVpnTargetNetworkResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"status" => {
obj.status =
Some(AssociationStatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateDhcpOptionsRequest {
pub dhcp_options_id: String,
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct AssociateDhcpOptionsRequestSerializer;
impl AssociateDhcpOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateDhcpOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DhcpOptionsId"),
&obj.dhcp_options_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateIamInstanceProfileRequest {
pub iam_instance_profile: IamInstanceProfileSpecification,
pub instance_id: String,
}
struct AssociateIamInstanceProfileRequestSerializer;
impl AssociateIamInstanceProfileRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateIamInstanceProfileRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
IamInstanceProfileSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
&obj.iam_instance_profile,
);
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateIamInstanceProfileResult {
pub iam_instance_profile_association: Option<IamInstanceProfileAssociation>,
}
struct AssociateIamInstanceProfileResultDeserializer;
impl AssociateIamInstanceProfileResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateIamInstanceProfileResult, XmlParseError> {
deserialize_elements::<_, AssociateIamInstanceProfileResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"iamInstanceProfileAssociation" => {
obj.iam_instance_profile_association =
Some(IamInstanceProfileAssociationDeserializer::deserialize(
"iamInstanceProfileAssociation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateRouteTableRequest {
pub dry_run: Option<bool>,
pub route_table_id: String,
pub subnet_id: String,
}
struct AssociateRouteTableRequestSerializer;
impl AssociateRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateRouteTableResult {
pub association_id: Option<String>,
}
struct AssociateRouteTableResultDeserializer;
impl AssociateRouteTableResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateRouteTableResult, XmlParseError> {
deserialize_elements::<_, AssociateRouteTableResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateSubnetCidrBlockRequest {
pub ipv_6_cidr_block: String,
pub subnet_id: String,
}
struct AssociateSubnetCidrBlockRequestSerializer;
impl AssociateSubnetCidrBlockRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateSubnetCidrBlockRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "Ipv6CidrBlock"),
&obj.ipv_6_cidr_block,
);
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateSubnetCidrBlockResult {
pub ipv_6_cidr_block_association: Option<SubnetIpv6CidrBlockAssociation>,
pub subnet_id: Option<String>,
}
struct AssociateSubnetCidrBlockResultDeserializer;
impl AssociateSubnetCidrBlockResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateSubnetCidrBlockResult, XmlParseError> {
deserialize_elements::<_, AssociateSubnetCidrBlockResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ipv6CidrBlockAssociation" => {
obj.ipv_6_cidr_block_association =
Some(SubnetIpv6CidrBlockAssociationDeserializer::deserialize(
"ipv6CidrBlockAssociation",
stack,
)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateTransitGatewayRouteTableRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
pub transit_gateway_route_table_id: String,
}
struct AssociateTransitGatewayRouteTableRequestSerializer;
impl AssociateTransitGatewayRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateTransitGatewayRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateTransitGatewayRouteTableResult {
pub association: Option<TransitGatewayAssociation>,
}
struct AssociateTransitGatewayRouteTableResultDeserializer;
impl AssociateTransitGatewayRouteTableResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateTransitGatewayRouteTableResult, XmlParseError> {
deserialize_elements::<_, AssociateTransitGatewayRouteTableResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"association" => {
obj.association = Some(TransitGatewayAssociationDeserializer::deserialize(
"association",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateVpcCidrBlockRequest {
pub amazon_provided_ipv_6_cidr_block: Option<bool>,
pub cidr_block: Option<String>,
pub vpc_id: String,
}
struct AssociateVpcCidrBlockRequestSerializer;
impl AssociateVpcCidrBlockRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AssociateVpcCidrBlockRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.amazon_provided_ipv_6_cidr_block {
params.put(
&format!("{}{}", prefix, "AmazonProvidedIpv6CidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.cidr_block {
params.put(&format!("{}{}", prefix, "CidrBlock"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateVpcCidrBlockResult {
pub cidr_block_association: Option<VpcCidrBlockAssociation>,
pub ipv_6_cidr_block_association: Option<VpcIpv6CidrBlockAssociation>,
pub vpc_id: Option<String>,
}
struct AssociateVpcCidrBlockResultDeserializer;
impl AssociateVpcCidrBlockResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateVpcCidrBlockResult, XmlParseError> {
deserialize_elements::<_, AssociateVpcCidrBlockResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"cidrBlockAssociation" => {
obj.cidr_block_association =
Some(VpcCidrBlockAssociationDeserializer::deserialize(
"cidrBlockAssociation",
stack,
)?);
}
"ipv6CidrBlockAssociation" => {
obj.ipv_6_cidr_block_association =
Some(VpcIpv6CidrBlockAssociationDeserializer::deserialize(
"ipv6CidrBlockAssociation",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociatedTargetNetwork {
pub network_id: Option<String>,
pub network_type: Option<String>,
}
struct AssociationIdListSerializer;
impl AssociationIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociationStatus {
pub code: Option<String>,
pub message: Option<String>,
}
struct AssociationStatusDeserializer;
impl AssociationStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociationStatus, XmlParseError> {
deserialize_elements::<_, AssociationStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(AssociationStatusCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AssociationStatusCodeDeserializer;
impl AssociationStatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachClassicLinkVpcRequest {
pub dry_run: Option<bool>,
pub groups: Vec<String>,
pub instance_id: String,
pub vpc_id: String,
}
struct AttachClassicLinkVpcRequestSerializer;
impl AttachClassicLinkVpcRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachClassicLinkVpcRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
GroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
&obj.groups,
);
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachClassicLinkVpcResult {
pub return_: Option<bool>,
}
struct AttachClassicLinkVpcResultDeserializer;
impl AttachClassicLinkVpcResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttachClassicLinkVpcResult, XmlParseError> {
deserialize_elements::<_, AttachClassicLinkVpcResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachInternetGatewayRequest {
pub dry_run: Option<bool>,
pub internet_gateway_id: String,
pub vpc_id: String,
}
struct AttachInternetGatewayRequestSerializer;
impl AttachInternetGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachInternetGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InternetGatewayId"),
&obj.internet_gateway_id,
);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachNetworkInterfaceRequest {
pub device_index: i64,
pub dry_run: Option<bool>,
pub instance_id: String,
pub network_interface_id: String,
}
struct AttachNetworkInterfaceRequestSerializer;
impl AttachNetworkInterfaceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachNetworkInterfaceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DeviceIndex"), &obj.device_index);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachNetworkInterfaceResult {
pub attachment_id: Option<String>,
}
struct AttachNetworkInterfaceResultDeserializer;
impl AttachNetworkInterfaceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttachNetworkInterfaceResult, XmlParseError> {
deserialize_elements::<_, AttachNetworkInterfaceResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"attachmentId" => {
obj.attachment_id =
Some(StringDeserializer::deserialize("attachmentId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachVolumeRequest {
pub device: String,
pub dry_run: Option<bool>,
pub instance_id: String,
pub volume_id: String,
}
struct AttachVolumeRequestSerializer;
impl AttachVolumeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachVolumeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Device"), &obj.device);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachVpnGatewayRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
pub vpn_gateway_id: String,
}
struct AttachVpnGatewayRequestSerializer;
impl AttachVpnGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachVpnGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
params.put(
&format!("{}{}", prefix, "VpnGatewayId"),
&obj.vpn_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachVpnGatewayResult {
pub vpc_attachment: Option<VpcAttachment>,
}
struct AttachVpnGatewayResultDeserializer;
impl AttachVpnGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttachVpnGatewayResult, XmlParseError> {
deserialize_elements::<_, AttachVpnGatewayResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"attachment" => {
obj.vpc_attachment =
Some(VpcAttachmentDeserializer::deserialize("attachment", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AttachmentStatusDeserializer;
impl AttachmentStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttributeBooleanValue {
pub value: Option<bool>,
}
struct AttributeBooleanValueDeserializer;
impl AttributeBooleanValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttributeBooleanValue, XmlParseError> {
deserialize_elements::<_, AttributeBooleanValue, _>(tag_name, stack, |name, stack, obj| {
match name {
"value" => {
obj.value = Some(BooleanDeserializer::deserialize("value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AttributeBooleanValueSerializer;
impl AttributeBooleanValueSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttributeBooleanValue) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttributeValue {
pub value: Option<String>,
}
struct AttributeValueDeserializer;
impl AttributeValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttributeValue, XmlParseError> {
deserialize_elements::<_, AttributeValue, _>(tag_name, stack, |name, stack, obj| {
match name {
"value" => {
obj.value = Some(StringDeserializer::deserialize("value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AttributeValueSerializer;
impl AttributeValueSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttributeValue) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AuthorizationRule {
pub access_all: Option<bool>,
pub client_vpn_endpoint_id: Option<String>,
pub description: Option<String>,
pub destination_cidr: Option<String>,
pub group_id: Option<String>,
pub status: Option<ClientVpnAuthorizationRuleStatus>,
}
struct AuthorizationRuleDeserializer;
impl AuthorizationRuleDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizationRule, XmlParseError> {
deserialize_elements::<_, AuthorizationRule, _>(tag_name, stack, |name, stack, obj| {
match name {
"accessAll" => {
obj.access_all = Some(BooleanDeserializer::deserialize("accessAll", stack)?);
}
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"destinationCidr" => {
obj.destination_cidr =
Some(StringDeserializer::deserialize("destinationCidr", stack)?);
}
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"status" => {
obj.status = Some(ClientVpnAuthorizationRuleStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AuthorizationRuleSetDeserializer;
impl AuthorizationRuleSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AuthorizationRule>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AuthorizationRuleDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AuthorizeClientVpnIngressRequest {
pub access_group_id: Option<String>,
pub authorize_all_groups: Option<bool>,
pub client_token: Option<String>,
pub client_vpn_endpoint_id: String,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub target_network_cidr: String,
}
struct AuthorizeClientVpnIngressRequestSerializer;
impl AuthorizeClientVpnIngressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AuthorizeClientVpnIngressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.access_group_id {
params.put(&format!("{}{}", prefix, "AccessGroupId"), &field_value);
}
if let Some(ref field_value) = obj.authorize_all_groups {
params.put(&format!("{}{}", prefix, "AuthorizeAllGroups"), &field_value);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TargetNetworkCidr"),
&obj.target_network_cidr,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AuthorizeClientVpnIngressResult {
pub status: Option<ClientVpnAuthorizationRuleStatus>,
}
struct AuthorizeClientVpnIngressResultDeserializer;
impl AuthorizeClientVpnIngressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizeClientVpnIngressResult, XmlParseError> {
deserialize_elements::<_, AuthorizeClientVpnIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"status" => {
obj.status =
Some(ClientVpnAuthorizationRuleStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AuthorizeSecurityGroupEgressRequest {
pub cidr_ip: Option<String>,
pub dry_run: Option<bool>,
pub from_port: Option<i64>,
pub group_id: String,
pub ip_permissions: Option<Vec<IpPermission>>,
pub ip_protocol: Option<String>,
pub source_security_group_name: Option<String>,
pub source_security_group_owner_id: Option<String>,
pub to_port: Option<i64>,
}
struct AuthorizeSecurityGroupEgressRequestSerializer;
impl AuthorizeSecurityGroupEgressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AuthorizeSecurityGroupEgressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_ip {
params.put(&format!("{}{}", prefix, "CidrIp"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.from_port {
params.put(&format!("{}{}", prefix, "FromPort"), &field_value);
}
params.put(&format!("{}{}", prefix, "GroupId"), &obj.group_id);
if let Some(ref field_value) = obj.ip_permissions {
IpPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpPermissions"),
field_value,
);
}
if let Some(ref field_value) = obj.ip_protocol {
params.put(&format!("{}{}", prefix, "IpProtocol"), &field_value);
}
if let Some(ref field_value) = obj.source_security_group_name {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.source_security_group_owner_id {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupOwnerId"),
&field_value,
);
}
if let Some(ref field_value) = obj.to_port {
params.put(&format!("{}{}", prefix, "ToPort"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AuthorizeSecurityGroupIngressRequest {
pub cidr_ip: Option<String>,
pub dry_run: Option<bool>,
pub from_port: Option<i64>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub ip_permissions: Option<Vec<IpPermission>>,
pub ip_protocol: Option<String>,
pub source_security_group_name: Option<String>,
pub source_security_group_owner_id: Option<String>,
pub to_port: Option<i64>,
}
struct AuthorizeSecurityGroupIngressRequestSerializer;
impl AuthorizeSecurityGroupIngressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AuthorizeSecurityGroupIngressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_ip {
params.put(&format!("{}{}", prefix, "CidrIp"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.from_port {
params.put(&format!("{}{}", prefix, "FromPort"), &field_value);
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.ip_permissions {
IpPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpPermissions"),
field_value,
);
}
if let Some(ref field_value) = obj.ip_protocol {
params.put(&format!("{}{}", prefix, "IpProtocol"), &field_value);
}
if let Some(ref field_value) = obj.source_security_group_name {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.source_security_group_owner_id {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupOwnerId"),
&field_value,
);
}
if let Some(ref field_value) = obj.to_port {
params.put(&format!("{}{}", prefix, "ToPort"), &field_value);
}
}
}
struct AutoAcceptSharedAttachmentsValueDeserializer;
impl AutoAcceptSharedAttachmentsValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AutoPlacementDeserializer;
impl AutoPlacementDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AvailabilityZone {
pub messages: Option<Vec<AvailabilityZoneMessage>>,
pub region_name: Option<String>,
pub state: Option<String>,
pub zone_id: Option<String>,
pub zone_name: Option<String>,
}
struct AvailabilityZoneDeserializer;
impl AvailabilityZoneDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityZone, XmlParseError> {
deserialize_elements::<_, AvailabilityZone, _>(tag_name, stack, |name, stack, obj| {
match name {
"messageSet" => {
obj.messages.get_or_insert(vec![]).extend(
AvailabilityZoneMessageListDeserializer::deserialize("messageSet", stack)?,
);
}
"regionName" => {
obj.region_name = Some(StringDeserializer::deserialize("regionName", stack)?);
}
"zoneState" => {
obj.state = Some(AvailabilityZoneStateDeserializer::deserialize(
"zoneState",
stack,
)?);
}
"zoneId" => {
obj.zone_id = Some(StringDeserializer::deserialize("zoneId", stack)?);
}
"zoneName" => {
obj.zone_name = Some(StringDeserializer::deserialize("zoneName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AvailabilityZoneListDeserializer;
impl AvailabilityZoneListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AvailabilityZone>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AvailabilityZoneDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AvailabilityZoneMessage {
pub message: Option<String>,
}
struct AvailabilityZoneMessageDeserializer;
impl AvailabilityZoneMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityZoneMessage, XmlParseError> {
deserialize_elements::<_, AvailabilityZoneMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct AvailabilityZoneMessageListDeserializer;
impl AvailabilityZoneMessageListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AvailabilityZoneMessage>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AvailabilityZoneMessageDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct AvailabilityZoneStateDeserializer;
impl AvailabilityZoneStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AvailableCapacity {
pub available_instance_capacity: Option<Vec<InstanceCapacity>>,
pub available_v_cpus: Option<i64>,
}
struct AvailableCapacityDeserializer;
impl AvailableCapacityDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailableCapacity, XmlParseError> {
deserialize_elements::<_, AvailableCapacity, _>(tag_name, stack, |name, stack, obj| {
match name {
"availableInstanceCapacity" => {
obj.available_instance_capacity
.get_or_insert(vec![])
.extend(AvailableInstanceCapacityListDeserializer::deserialize(
"availableInstanceCapacity",
stack,
)?);
}
"availableVCpus" => {
obj.available_v_cpus =
Some(IntegerDeserializer::deserialize("availableVCpus", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AvailableInstanceCapacityListDeserializer;
impl AvailableInstanceCapacityListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceCapacity>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceCapacityDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct BatchStateDeserializer;
impl BatchStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct BillingProductListSerializer;
impl BillingProductListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct BlobDeserializer;
impl BlobDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bytes::Bytes, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?.into();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BlobAttributeValue {
pub value: Option<bytes::Bytes>,
}
struct BlobAttributeValueSerializer;
impl BlobAttributeValueSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BlobAttributeValue) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.value {
params.put(
&format!("{}{}", prefix, "Value"),
::std::str::from_utf8(&field_value).unwrap(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BlockDeviceMapping {
pub device_name: Option<String>,
pub ebs: Option<EbsBlockDevice>,
pub no_device: Option<String>,
pub virtual_name: Option<String>,
}
struct BlockDeviceMappingDeserializer;
impl BlockDeviceMappingDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BlockDeviceMapping, XmlParseError> {
deserialize_elements::<_, BlockDeviceMapping, _>(tag_name, stack, |name, stack, obj| {
match name {
"deviceName" => {
obj.device_name = Some(StringDeserializer::deserialize("deviceName", stack)?);
}
"ebs" => {
obj.ebs = Some(EbsBlockDeviceDeserializer::deserialize("ebs", stack)?);
}
"noDevice" => {
obj.no_device = Some(StringDeserializer::deserialize("noDevice", stack)?);
}
"virtualName" => {
obj.virtual_name = Some(StringDeserializer::deserialize("virtualName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct BlockDeviceMappingSerializer;
impl BlockDeviceMappingSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BlockDeviceMapping) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.device_name {
params.put(&format!("{}{}", prefix, "DeviceName"), &field_value);
}
if let Some(ref field_value) = obj.ebs {
EbsBlockDeviceSerializer::serialize(
params,
&format!("{}{}", prefix, "Ebs"),
field_value,
);
}
if let Some(ref field_value) = obj.no_device {
params.put(&format!("{}{}", prefix, "NoDevice"), &field_value);
}
if let Some(ref field_value) = obj.virtual_name {
params.put(&format!("{}{}", prefix, "VirtualName"), &field_value);
}
}
}
struct BlockDeviceMappingListDeserializer;
impl BlockDeviceMappingListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<BlockDeviceMapping>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(BlockDeviceMappingDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct BlockDeviceMappingListSerializer;
impl BlockDeviceMappingListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<BlockDeviceMapping>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
BlockDeviceMappingSerializer::serialize(params, &key, obj);
}
}
}
struct BlockDeviceMappingRequestListSerializer;
impl BlockDeviceMappingRequestListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<BlockDeviceMapping>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
BlockDeviceMappingSerializer::serialize(params, &key, obj);
}
}
}
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct BundleIdStringListSerializer;
impl BundleIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BundleInstanceRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
pub storage: Storage,
}
struct BundleInstanceRequestSerializer;
impl BundleInstanceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BundleInstanceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
StorageSerializer::serialize(params, &format!("{}{}", prefix, "Storage"), &obj.storage);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BundleInstanceResult {
pub bundle_task: Option<BundleTask>,
}
struct BundleInstanceResultDeserializer;
impl BundleInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BundleInstanceResult, XmlParseError> {
deserialize_elements::<_, BundleInstanceResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"bundleInstanceTask" => {
obj.bundle_task = Some(BundleTaskDeserializer::deserialize(
"bundleInstanceTask",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BundleTask {
pub bundle_id: Option<String>,
pub bundle_task_error: Option<BundleTaskError>,
pub instance_id: Option<String>,
pub progress: Option<String>,
pub start_time: Option<String>,
pub state: Option<String>,
pub storage: Option<Storage>,
pub update_time: Option<String>,
}
struct BundleTaskDeserializer;
impl BundleTaskDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BundleTask, XmlParseError> {
deserialize_elements::<_, BundleTask, _>(tag_name, stack, |name, stack, obj| {
match name {
"bundleId" => {
obj.bundle_id = Some(StringDeserializer::deserialize("bundleId", stack)?);
}
"error" => {
obj.bundle_task_error =
Some(BundleTaskErrorDeserializer::deserialize("error", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"startTime" => {
obj.start_time = Some(DateTimeDeserializer::deserialize("startTime", stack)?);
}
"state" => {
obj.state = Some(BundleTaskStateDeserializer::deserialize("state", stack)?);
}
"storage" => {
obj.storage = Some(StorageDeserializer::deserialize("storage", stack)?);
}
"updateTime" => {
obj.update_time = Some(DateTimeDeserializer::deserialize("updateTime", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BundleTaskError {
pub code: Option<String>,
pub message: Option<String>,
}
struct BundleTaskErrorDeserializer;
impl BundleTaskErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BundleTaskError, XmlParseError> {
deserialize_elements::<_, BundleTaskError, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(StringDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct BundleTaskListDeserializer;
impl BundleTaskListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<BundleTask>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(BundleTaskDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct BundleTaskStateDeserializer;
impl BundleTaskStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ByoipCidr {
pub cidr: Option<String>,
pub description: Option<String>,
pub state: Option<String>,
pub status_message: Option<String>,
}
struct ByoipCidrDeserializer;
impl ByoipCidrDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ByoipCidr, XmlParseError> {
deserialize_elements::<_, ByoipCidr, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidr" => {
obj.cidr = Some(StringDeserializer::deserialize("cidr", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"state" => {
obj.state = Some(ByoipCidrStateDeserializer::deserialize("state", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ByoipCidrSetDeserializer;
impl ByoipCidrSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ByoipCidr>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ByoipCidrDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ByoipCidrStateDeserializer;
impl ByoipCidrStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct CancelBatchErrorCodeDeserializer;
impl CancelBatchErrorCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelBundleTaskRequest {
pub bundle_id: String,
pub dry_run: Option<bool>,
}
struct CancelBundleTaskRequestSerializer;
impl CancelBundleTaskRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelBundleTaskRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "BundleId"), &obj.bundle_id);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelBundleTaskResult {
pub bundle_task: Option<BundleTask>,
}
struct CancelBundleTaskResultDeserializer;
impl CancelBundleTaskResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelBundleTaskResult, XmlParseError> {
deserialize_elements::<_, CancelBundleTaskResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"bundleInstanceTask" => {
obj.bundle_task = Some(BundleTaskDeserializer::deserialize(
"bundleInstanceTask",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelCapacityReservationRequest {
pub capacity_reservation_id: String,
pub dry_run: Option<bool>,
}
struct CancelCapacityReservationRequestSerializer;
impl CancelCapacityReservationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelCapacityReservationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CapacityReservationId"),
&obj.capacity_reservation_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelCapacityReservationResult {
pub return_: Option<bool>,
}
struct CancelCapacityReservationResultDeserializer;
impl CancelCapacityReservationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelCapacityReservationResult, XmlParseError> {
deserialize_elements::<_, CancelCapacityReservationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelConversionRequest {
pub conversion_task_id: String,
pub dry_run: Option<bool>,
pub reason_message: Option<String>,
}
struct CancelConversionRequestSerializer;
impl CancelConversionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelConversionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ConversionTaskId"),
&obj.conversion_task_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.reason_message {
params.put(&format!("{}{}", prefix, "ReasonMessage"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelExportTaskRequest {
pub export_task_id: String,
}
struct CancelExportTaskRequestSerializer;
impl CancelExportTaskRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelExportTaskRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ExportTaskId"),
&obj.export_task_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelImportTaskRequest {
pub cancel_reason: Option<String>,
pub dry_run: Option<bool>,
pub import_task_id: Option<String>,
}
struct CancelImportTaskRequestSerializer;
impl CancelImportTaskRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelImportTaskRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cancel_reason {
params.put(&format!("{}{}", prefix, "CancelReason"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.import_task_id {
params.put(&format!("{}{}", prefix, "ImportTaskId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelImportTaskResult {
pub import_task_id: Option<String>,
pub previous_state: Option<String>,
pub state: Option<String>,
}
struct CancelImportTaskResultDeserializer;
impl CancelImportTaskResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelImportTaskResult, XmlParseError> {
deserialize_elements::<_, CancelImportTaskResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"importTaskId" => {
obj.import_task_id =
Some(StringDeserializer::deserialize("importTaskId", stack)?);
}
"previousState" => {
obj.previous_state =
Some(StringDeserializer::deserialize("previousState", stack)?);
}
"state" => {
obj.state = Some(StringDeserializer::deserialize("state", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelReservedInstancesListingRequest {
pub reserved_instances_listing_id: String,
}
struct CancelReservedInstancesListingRequestSerializer;
impl CancelReservedInstancesListingRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelReservedInstancesListingRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ReservedInstancesListingId"),
&obj.reserved_instances_listing_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelReservedInstancesListingResult {
pub reserved_instances_listings: Option<Vec<ReservedInstancesListing>>,
}
struct CancelReservedInstancesListingResultDeserializer;
impl CancelReservedInstancesListingResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelReservedInstancesListingResult, XmlParseError> {
deserialize_elements::<_, CancelReservedInstancesListingResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesListingsSet" => {
obj.reserved_instances_listings
.get_or_insert(vec![])
.extend(ReservedInstancesListingListDeserializer::deserialize(
"reservedInstancesListingsSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotFleetRequestsError {
pub code: Option<String>,
pub message: Option<String>,
}
struct CancelSpotFleetRequestsErrorDeserializer;
impl CancelSpotFleetRequestsErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelSpotFleetRequestsError, XmlParseError> {
deserialize_elements::<_, CancelSpotFleetRequestsError, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(CancelBatchErrorCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotFleetRequestsErrorItem {
pub error: Option<CancelSpotFleetRequestsError>,
pub spot_fleet_request_id: Option<String>,
}
struct CancelSpotFleetRequestsErrorItemDeserializer;
impl CancelSpotFleetRequestsErrorItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelSpotFleetRequestsErrorItem, XmlParseError> {
deserialize_elements::<_, CancelSpotFleetRequestsErrorItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"error" => {
obj.error = Some(CancelSpotFleetRequestsErrorDeserializer::deserialize(
"error", stack,
)?);
}
"spotFleetRequestId" => {
obj.spot_fleet_request_id = Some(StringDeserializer::deserialize(
"spotFleetRequestId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct CancelSpotFleetRequestsErrorSetDeserializer;
impl CancelSpotFleetRequestsErrorSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CancelSpotFleetRequestsErrorItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CancelSpotFleetRequestsErrorItemDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotFleetRequestsRequest {
pub dry_run: Option<bool>,
pub spot_fleet_request_ids: Vec<String>,
pub terminate_instances: bool,
}
struct CancelSpotFleetRequestsRequestSerializer;
impl CancelSpotFleetRequestsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelSpotFleetRequestsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotFleetRequestId"),
&obj.spot_fleet_request_ids,
);
params.put(
&format!("{}{}", prefix, "TerminateInstances"),
&obj.terminate_instances,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotFleetRequestsResponse {
pub successful_fleet_requests: Option<Vec<CancelSpotFleetRequestsSuccessItem>>,
pub unsuccessful_fleet_requests: Option<Vec<CancelSpotFleetRequestsErrorItem>>,
}
struct CancelSpotFleetRequestsResponseDeserializer;
impl CancelSpotFleetRequestsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelSpotFleetRequestsResponse, XmlParseError> {
deserialize_elements::<_, CancelSpotFleetRequestsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"successfulFleetRequestSet" => {
obj.successful_fleet_requests.get_or_insert(vec![]).extend(
CancelSpotFleetRequestsSuccessSetDeserializer::deserialize(
"successfulFleetRequestSet",
stack,
)?,
);
}
"unsuccessfulFleetRequestSet" => {
obj.unsuccessful_fleet_requests
.get_or_insert(vec![])
.extend(CancelSpotFleetRequestsErrorSetDeserializer::deserialize(
"unsuccessfulFleetRequestSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotFleetRequestsSuccessItem {
pub current_spot_fleet_request_state: Option<String>,
pub previous_spot_fleet_request_state: Option<String>,
pub spot_fleet_request_id: Option<String>,
}
struct CancelSpotFleetRequestsSuccessItemDeserializer;
impl CancelSpotFleetRequestsSuccessItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelSpotFleetRequestsSuccessItem, XmlParseError> {
deserialize_elements::<_, CancelSpotFleetRequestsSuccessItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"currentSpotFleetRequestState" => {
obj.current_spot_fleet_request_state =
Some(BatchStateDeserializer::deserialize(
"currentSpotFleetRequestState",
stack,
)?);
}
"previousSpotFleetRequestState" => {
obj.previous_spot_fleet_request_state =
Some(BatchStateDeserializer::deserialize(
"previousSpotFleetRequestState",
stack,
)?);
}
"spotFleetRequestId" => {
obj.spot_fleet_request_id = Some(StringDeserializer::deserialize(
"spotFleetRequestId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct CancelSpotFleetRequestsSuccessSetDeserializer;
impl CancelSpotFleetRequestsSuccessSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CancelSpotFleetRequestsSuccessItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CancelSpotFleetRequestsSuccessItemDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct CancelSpotInstanceRequestStateDeserializer;
impl CancelSpotInstanceRequestStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotInstanceRequestsRequest {
pub dry_run: Option<bool>,
pub spot_instance_request_ids: Vec<String>,
}
struct CancelSpotInstanceRequestsRequestSerializer;
impl CancelSpotInstanceRequestsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelSpotInstanceRequestsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
SpotInstanceRequestIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotInstanceRequestId"),
&obj.spot_instance_request_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelSpotInstanceRequestsResult {
pub cancelled_spot_instance_requests: Option<Vec<CancelledSpotInstanceRequest>>,
}
struct CancelSpotInstanceRequestsResultDeserializer;
impl CancelSpotInstanceRequestsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelSpotInstanceRequestsResult, XmlParseError> {
deserialize_elements::<_, CancelSpotInstanceRequestsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"spotInstanceRequestSet" => {
obj.cancelled_spot_instance_requests
.get_or_insert(vec![])
.extend(CancelledSpotInstanceRequestListDeserializer::deserialize(
"spotInstanceRequestSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CancelledSpotInstanceRequest {
pub spot_instance_request_id: Option<String>,
pub state: Option<String>,
}
struct CancelledSpotInstanceRequestDeserializer;
impl CancelledSpotInstanceRequestDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CancelledSpotInstanceRequest, XmlParseError> {
deserialize_elements::<_, CancelledSpotInstanceRequest, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"spotInstanceRequestId" => {
obj.spot_instance_request_id = Some(StringDeserializer::deserialize(
"spotInstanceRequestId",
stack,
)?);
}
"state" => {
obj.state = Some(CancelSpotInstanceRequestStateDeserializer::deserialize(
"state", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct CancelledSpotInstanceRequestListDeserializer;
impl CancelledSpotInstanceRequestListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CancelledSpotInstanceRequest>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CancelledSpotInstanceRequestDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CapacityReservation {
pub availability_zone: Option<String>,
pub available_instance_count: Option<i64>,
pub capacity_reservation_id: Option<String>,
pub create_date: Option<String>,
pub ebs_optimized: Option<bool>,
pub end_date: Option<String>,
pub end_date_type: Option<String>,
pub ephemeral_storage: Option<bool>,
pub instance_match_criteria: Option<String>,
pub instance_platform: Option<String>,
pub instance_type: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub tenancy: Option<String>,
pub total_instance_count: Option<i64>,
}
struct CapacityReservationDeserializer;
impl CapacityReservationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CapacityReservation, XmlParseError> {
deserialize_elements::<_, CapacityReservation, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"availableInstanceCount" => {
obj.available_instance_count = Some(IntegerDeserializer::deserialize(
"availableInstanceCount",
stack,
)?);
}
"capacityReservationId" => {
obj.capacity_reservation_id = Some(StringDeserializer::deserialize(
"capacityReservationId",
stack,
)?);
}
"createDate" => {
obj.create_date = Some(DateTimeDeserializer::deserialize("createDate", stack)?);
}
"ebsOptimized" => {
obj.ebs_optimized =
Some(BooleanDeserializer::deserialize("ebsOptimized", stack)?);
}
"endDate" => {
obj.end_date = Some(DateTimeDeserializer::deserialize("endDate", stack)?);
}
"endDateType" => {
obj.end_date_type =
Some(EndDateTypeDeserializer::deserialize("endDateType", stack)?);
}
"ephemeralStorage" => {
obj.ephemeral_storage =
Some(BooleanDeserializer::deserialize("ephemeralStorage", stack)?);
}
"instanceMatchCriteria" => {
obj.instance_match_criteria =
Some(InstanceMatchCriteriaDeserializer::deserialize(
"instanceMatchCriteria",
stack,
)?);
}
"instancePlatform" => {
obj.instance_platform = Some(
CapacityReservationInstancePlatformDeserializer::deserialize(
"instancePlatform",
stack,
)?,
);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
"state" => {
obj.state = Some(CapacityReservationStateDeserializer::deserialize(
"state", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"tenancy" => {
obj.tenancy = Some(CapacityReservationTenancyDeserializer::deserialize(
"tenancy", stack,
)?);
}
"totalInstanceCount" => {
obj.total_instance_count = Some(IntegerDeserializer::deserialize(
"totalInstanceCount",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CapacityReservationIdSetSerializer;
impl CapacityReservationIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct CapacityReservationInstancePlatformDeserializer;
impl CapacityReservationInstancePlatformDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct CapacityReservationPreferenceDeserializer;
impl CapacityReservationPreferenceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct CapacityReservationSetDeserializer;
impl CapacityReservationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CapacityReservation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CapacityReservationDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CapacityReservationSpecification {
pub capacity_reservation_preference: Option<String>,
pub capacity_reservation_target: Option<CapacityReservationTarget>,
}
struct CapacityReservationSpecificationSerializer;
impl CapacityReservationSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CapacityReservationSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capacity_reservation_preference {
params.put(
&format!("{}{}", prefix, "CapacityReservationPreference"),
&field_value,
);
}
if let Some(ref field_value) = obj.capacity_reservation_target {
CapacityReservationTargetSerializer::serialize(
params,
&format!("{}{}", prefix, "CapacityReservationTarget"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CapacityReservationSpecificationResponse {
pub capacity_reservation_preference: Option<String>,
pub capacity_reservation_target: Option<CapacityReservationTargetResponse>,
}
struct CapacityReservationSpecificationResponseDeserializer;
impl CapacityReservationSpecificationResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CapacityReservationSpecificationResponse, XmlParseError> {
deserialize_elements::<_, CapacityReservationSpecificationResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"capacityReservationPreference" => {
obj.capacity_reservation_preference =
Some(CapacityReservationPreferenceDeserializer::deserialize(
"capacityReservationPreference",
stack,
)?);
}
"capacityReservationTarget" => {
obj.capacity_reservation_target =
Some(CapacityReservationTargetResponseDeserializer::deserialize(
"capacityReservationTarget",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct CapacityReservationStateDeserializer;
impl CapacityReservationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CapacityReservationTarget {
pub capacity_reservation_id: Option<String>,
}
struct CapacityReservationTargetSerializer;
impl CapacityReservationTargetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CapacityReservationTarget) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capacity_reservation_id {
params.put(
&format!("{}{}", prefix, "CapacityReservationId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CapacityReservationTargetResponse {
pub capacity_reservation_id: Option<String>,
}
struct CapacityReservationTargetResponseDeserializer;
impl CapacityReservationTargetResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CapacityReservationTargetResponse, XmlParseError> {
deserialize_elements::<_, CapacityReservationTargetResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"capacityReservationId" => {
obj.capacity_reservation_id = Some(StringDeserializer::deserialize(
"capacityReservationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct CapacityReservationTenancyDeserializer;
impl CapacityReservationTenancyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CertificateAuthentication {
pub client_root_certificate_chain: Option<String>,
}
struct CertificateAuthenticationDeserializer;
impl CertificateAuthenticationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CertificateAuthentication, XmlParseError> {
deserialize_elements::<_, CertificateAuthentication, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientRootCertificateChain" => {
obj.client_root_certificate_chain = Some(StringDeserializer::deserialize(
"clientRootCertificateChain",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CertificateAuthenticationRequest {
pub client_root_certificate_chain_arn: Option<String>,
}
struct CertificateAuthenticationRequestSerializer;
impl CertificateAuthenticationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CertificateAuthenticationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_root_certificate_chain_arn {
params.put(
&format!("{}{}", prefix, "ClientRootCertificateChainArn"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CidrAuthorizationContext {
pub message: String,
pub signature: String,
}
struct CidrAuthorizationContextSerializer;
impl CidrAuthorizationContextSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CidrAuthorizationContext) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Message"), &obj.message);
params.put(&format!("{}{}", prefix, "Signature"), &obj.signature);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CidrBlock {
pub cidr_block: Option<String>,
}
struct CidrBlockDeserializer;
impl CidrBlockDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CidrBlock, XmlParseError> {
deserialize_elements::<_, CidrBlock, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidrBlock" => {
obj.cidr_block = Some(StringDeserializer::deserialize("cidrBlock", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CidrBlockSetDeserializer;
impl CidrBlockSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CidrBlock>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CidrBlockDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClassicLinkDnsSupport {
pub classic_link_dns_supported: Option<bool>,
pub vpc_id: Option<String>,
}
struct ClassicLinkDnsSupportDeserializer;
impl ClassicLinkDnsSupportDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClassicLinkDnsSupport, XmlParseError> {
deserialize_elements::<_, ClassicLinkDnsSupport, _>(tag_name, stack, |name, stack, obj| {
match name {
"classicLinkDnsSupported" => {
obj.classic_link_dns_supported = Some(BooleanDeserializer::deserialize(
"classicLinkDnsSupported",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ClassicLinkDnsSupportListDeserializer;
impl ClassicLinkDnsSupportListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClassicLinkDnsSupport>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClassicLinkDnsSupportDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClassicLinkInstance {
pub groups: Option<Vec<GroupIdentifier>>,
pub instance_id: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct ClassicLinkInstanceDeserializer;
impl ClassicLinkInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClassicLinkInstance, XmlParseError> {
deserialize_elements::<_, ClassicLinkInstance, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ClassicLinkInstanceListDeserializer;
impl ClassicLinkInstanceListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClassicLinkInstance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClassicLinkInstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClassicLoadBalancer {
pub name: Option<String>,
}
struct ClassicLoadBalancerDeserializer;
impl ClassicLoadBalancerDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClassicLoadBalancer, XmlParseError> {
deserialize_elements::<_, ClassicLoadBalancer, _>(tag_name, stack, |name, stack, obj| {
match name {
"name" => {
obj.name = Some(StringDeserializer::deserialize("name", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ClassicLoadBalancerSerializer;
impl ClassicLoadBalancerSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ClassicLoadBalancer) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
}
}
struct ClassicLoadBalancersDeserializer;
impl ClassicLoadBalancersDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClassicLoadBalancer>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClassicLoadBalancerDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ClassicLoadBalancersSerializer;
impl ClassicLoadBalancersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ClassicLoadBalancer>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ClassicLoadBalancerSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClassicLoadBalancersConfig {
pub classic_load_balancers: Option<Vec<ClassicLoadBalancer>>,
}
struct ClassicLoadBalancersConfigDeserializer;
impl ClassicLoadBalancersConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClassicLoadBalancersConfig, XmlParseError> {
deserialize_elements::<_, ClassicLoadBalancersConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"classicLoadBalancers" => {
obj.classic_load_balancers.get_or_insert(vec![]).extend(
ClassicLoadBalancersDeserializer::deserialize(
"classicLoadBalancers",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClassicLoadBalancersConfigSerializer;
impl ClassicLoadBalancersConfigSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ClassicLoadBalancersConfig) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.classic_load_balancers {
ClassicLoadBalancersSerializer::serialize(
params,
&format!("{}{}", prefix, "ClassicLoadBalancers"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientCertificateRevocationListStatus {
pub code: Option<String>,
pub message: Option<String>,
}
struct ClientCertificateRevocationListStatusDeserializer;
impl ClientCertificateRevocationListStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientCertificateRevocationListStatus, XmlParseError> {
deserialize_elements::<_, ClientCertificateRevocationListStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(
ClientCertificateRevocationListStatusCodeDeserializer::deserialize(
"code", stack,
)?,
);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClientCertificateRevocationListStatusCodeDeserializer;
impl ClientCertificateRevocationListStatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientData {
pub comment: Option<String>,
pub upload_end: Option<String>,
pub upload_size: Option<f64>,
pub upload_start: Option<String>,
}
struct ClientDataSerializer;
impl ClientDataSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ClientData) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.comment {
params.put(&format!("{}{}", prefix, "Comment"), &field_value);
}
if let Some(ref field_value) = obj.upload_end {
params.put(&format!("{}{}", prefix, "UploadEnd"), &field_value);
}
if let Some(ref field_value) = obj.upload_size {
params.put(&format!("{}{}", prefix, "UploadSize"), &field_value);
}
if let Some(ref field_value) = obj.upload_start {
params.put(&format!("{}{}", prefix, "UploadStart"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnAuthentication {
pub active_directory: Option<DirectoryServiceAuthentication>,
pub mutual_authentication: Option<CertificateAuthentication>,
pub type_: Option<String>,
}
struct ClientVpnAuthenticationDeserializer;
impl ClientVpnAuthenticationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnAuthentication, XmlParseError> {
deserialize_elements::<_, ClientVpnAuthentication, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"activeDirectory" => {
obj.active_directory =
Some(DirectoryServiceAuthenticationDeserializer::deserialize(
"activeDirectory",
stack,
)?);
}
"mutualAuthentication" => {
obj.mutual_authentication =
Some(CertificateAuthenticationDeserializer::deserialize(
"mutualAuthentication",
stack,
)?);
}
"type" => {
obj.type_ = Some(ClientVpnAuthenticationTypeDeserializer::deserialize(
"type", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClientVpnAuthenticationListDeserializer;
impl ClientVpnAuthenticationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClientVpnAuthentication>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClientVpnAuthenticationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnAuthenticationRequest {
pub active_directory: Option<DirectoryServiceAuthenticationRequest>,
pub mutual_authentication: Option<CertificateAuthenticationRequest>,
pub type_: Option<String>,
}
struct ClientVpnAuthenticationRequestSerializer;
impl ClientVpnAuthenticationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ClientVpnAuthenticationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.active_directory {
DirectoryServiceAuthenticationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "ActiveDirectory"),
field_value,
);
}
if let Some(ref field_value) = obj.mutual_authentication {
CertificateAuthenticationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "MutualAuthentication"),
field_value,
);
}
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
}
}
struct ClientVpnAuthenticationRequestListSerializer;
impl ClientVpnAuthenticationRequestListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ClientVpnAuthenticationRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ClientVpnAuthenticationRequestSerializer::serialize(params, &key, obj);
}
}
}
struct ClientVpnAuthenticationTypeDeserializer;
impl ClientVpnAuthenticationTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnAuthorizationRuleStatus {
pub code: Option<String>,
pub message: Option<String>,
}
struct ClientVpnAuthorizationRuleStatusDeserializer;
impl ClientVpnAuthorizationRuleStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnAuthorizationRuleStatus, XmlParseError> {
deserialize_elements::<_, ClientVpnAuthorizationRuleStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(
ClientVpnAuthorizationRuleStatusCodeDeserializer::deserialize(
"code", stack,
)?,
);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClientVpnAuthorizationRuleStatusCodeDeserializer;
impl ClientVpnAuthorizationRuleStatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnConnection {
pub client_ip: Option<String>,
pub client_vpn_endpoint_id: Option<String>,
pub common_name: Option<String>,
pub connection_end_time: Option<String>,
pub connection_established_time: Option<String>,
pub connection_id: Option<String>,
pub egress_bytes: Option<String>,
pub egress_packets: Option<String>,
pub ingress_bytes: Option<String>,
pub ingress_packets: Option<String>,
pub status: Option<ClientVpnConnectionStatus>,
pub timestamp: Option<String>,
pub username: Option<String>,
}
struct ClientVpnConnectionDeserializer;
impl ClientVpnConnectionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnConnection, XmlParseError> {
deserialize_elements::<_, ClientVpnConnection, _>(tag_name, stack, |name, stack, obj| {
match name {
"clientIp" => {
obj.client_ip = Some(StringDeserializer::deserialize("clientIp", stack)?);
}
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"commonName" => {
obj.common_name = Some(StringDeserializer::deserialize("commonName", stack)?);
}
"connectionEndTime" => {
obj.connection_end_time =
Some(StringDeserializer::deserialize("connectionEndTime", stack)?);
}
"connectionEstablishedTime" => {
obj.connection_established_time = Some(StringDeserializer::deserialize(
"connectionEstablishedTime",
stack,
)?);
}
"connectionId" => {
obj.connection_id =
Some(StringDeserializer::deserialize("connectionId", stack)?);
}
"egressBytes" => {
obj.egress_bytes = Some(StringDeserializer::deserialize("egressBytes", stack)?);
}
"egressPackets" => {
obj.egress_packets =
Some(StringDeserializer::deserialize("egressPackets", stack)?);
}
"ingressBytes" => {
obj.ingress_bytes =
Some(StringDeserializer::deserialize("ingressBytes", stack)?);
}
"ingressPackets" => {
obj.ingress_packets =
Some(StringDeserializer::deserialize("ingressPackets", stack)?);
}
"status" => {
obj.status = Some(ClientVpnConnectionStatusDeserializer::deserialize(
"status", stack,
)?);
}
"timestamp" => {
obj.timestamp = Some(StringDeserializer::deserialize("timestamp", stack)?);
}
"username" => {
obj.username = Some(StringDeserializer::deserialize("username", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ClientVpnConnectionSetDeserializer;
impl ClientVpnConnectionSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClientVpnConnection>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClientVpnConnectionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnConnectionStatus {
pub code: Option<String>,
pub message: Option<String>,
}
struct ClientVpnConnectionStatusDeserializer;
impl ClientVpnConnectionStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnConnectionStatus, XmlParseError> {
deserialize_elements::<_, ClientVpnConnectionStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(ClientVpnConnectionStatusCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClientVpnConnectionStatusCodeDeserializer;
impl ClientVpnConnectionStatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnEndpoint {
pub authentication_options: Option<Vec<ClientVpnAuthentication>>,
pub client_cidr_block: Option<String>,
pub client_vpn_endpoint_id: Option<String>,
pub connection_log_options: Option<ConnectionLogResponseOptions>,
pub creation_time: Option<String>,
pub deletion_time: Option<String>,
pub description: Option<String>,
pub dns_name: Option<String>,
pub dns_servers: Option<Vec<String>>,
pub server_certificate_arn: Option<String>,
pub split_tunnel: Option<bool>,
pub status: Option<ClientVpnEndpointStatus>,
pub tags: Option<Vec<Tag>>,
pub transport_protocol: Option<String>,
pub vpn_protocol: Option<String>,
}
struct ClientVpnEndpointDeserializer;
impl ClientVpnEndpointDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnEndpoint, XmlParseError> {
deserialize_elements::<_, ClientVpnEndpoint, _>(tag_name, stack, |name, stack, obj| {
match name {
"authenticationOptions" => {
obj.authentication_options.get_or_insert(vec![]).extend(
ClientVpnAuthenticationListDeserializer::deserialize(
"authenticationOptions",
stack,
)?,
);
}
"clientCidrBlock" => {
obj.client_cidr_block =
Some(StringDeserializer::deserialize("clientCidrBlock", stack)?);
}
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"connectionLogOptions" => {
obj.connection_log_options =
Some(ConnectionLogResponseOptionsDeserializer::deserialize(
"connectionLogOptions",
stack,
)?);
}
"creationTime" => {
obj.creation_time =
Some(StringDeserializer::deserialize("creationTime", stack)?);
}
"deletionTime" => {
obj.deletion_time =
Some(StringDeserializer::deserialize("deletionTime", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"dnsName" => {
obj.dns_name = Some(StringDeserializer::deserialize("dnsName", stack)?);
}
"dnsServer" => {
obj.dns_servers.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("dnsServer", stack)?,
);
}
"serverCertificateArn" => {
obj.server_certificate_arn = Some(StringDeserializer::deserialize(
"serverCertificateArn",
stack,
)?);
}
"splitTunnel" => {
obj.split_tunnel =
Some(BooleanDeserializer::deserialize("splitTunnel", stack)?);
}
"status" => {
obj.status = Some(ClientVpnEndpointStatusDeserializer::deserialize(
"status", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"transportProtocol" => {
obj.transport_protocol = Some(TransportProtocolDeserializer::deserialize(
"transportProtocol",
stack,
)?);
}
"vpnProtocol" => {
obj.vpn_protocol =
Some(VpnProtocolDeserializer::deserialize("vpnProtocol", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnEndpointStatus {
pub code: Option<String>,
pub message: Option<String>,
}
struct ClientVpnEndpointStatusDeserializer;
impl ClientVpnEndpointStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnEndpointStatus, XmlParseError> {
deserialize_elements::<_, ClientVpnEndpointStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(ClientVpnEndpointStatusCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClientVpnEndpointStatusCodeDeserializer;
impl ClientVpnEndpointStatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnRoute {
pub client_vpn_endpoint_id: Option<String>,
pub description: Option<String>,
pub destination_cidr: Option<String>,
pub origin: Option<String>,
pub status: Option<ClientVpnRouteStatus>,
pub target_subnet: Option<String>,
pub type_: Option<String>,
}
struct ClientVpnRouteDeserializer;
impl ClientVpnRouteDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnRoute, XmlParseError> {
deserialize_elements::<_, ClientVpnRoute, _>(tag_name, stack, |name, stack, obj| {
match name {
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"destinationCidr" => {
obj.destination_cidr =
Some(StringDeserializer::deserialize("destinationCidr", stack)?);
}
"origin" => {
obj.origin = Some(StringDeserializer::deserialize("origin", stack)?);
}
"status" => {
obj.status = Some(ClientVpnRouteStatusDeserializer::deserialize(
"status", stack,
)?);
}
"targetSubnet" => {
obj.target_subnet =
Some(StringDeserializer::deserialize("targetSubnet", stack)?);
}
"type" => {
obj.type_ = Some(StringDeserializer::deserialize("type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ClientVpnRouteSetDeserializer;
impl ClientVpnRouteSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClientVpnRoute>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClientVpnRouteDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClientVpnRouteStatus {
pub code: Option<String>,
pub message: Option<String>,
}
struct ClientVpnRouteStatusDeserializer;
impl ClientVpnRouteStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClientVpnRouteStatus, XmlParseError> {
deserialize_elements::<_, ClientVpnRouteStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(ClientVpnRouteStatusCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ClientVpnRouteStatusCodeDeserializer;
impl ClientVpnRouteStatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ClientVpnSecurityGroupIdSetDeserializer;
impl ClientVpnSecurityGroupIdSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ClientVpnSecurityGroupIdSetSerializer;
impl ClientVpnSecurityGroupIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ConfirmProductInstanceRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
pub product_code: String,
}
struct ConfirmProductInstanceRequestSerializer;
impl ConfirmProductInstanceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ConfirmProductInstanceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(&format!("{}{}", prefix, "ProductCode"), &obj.product_code);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ConfirmProductInstanceResult {
pub owner_id: Option<String>,
pub return_: Option<bool>,
}
struct ConfirmProductInstanceResultDeserializer;
impl ConfirmProductInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ConfirmProductInstanceResult, XmlParseError> {
deserialize_elements::<_, ConfirmProductInstanceResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ConnectionLogOptions {
pub cloudwatch_log_group: Option<String>,
pub cloudwatch_log_stream: Option<String>,
pub enabled: Option<bool>,
}
struct ConnectionLogOptionsSerializer;
impl ConnectionLogOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ConnectionLogOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cloudwatch_log_group {
params.put(&format!("{}{}", prefix, "CloudwatchLogGroup"), &field_value);
}
if let Some(ref field_value) = obj.cloudwatch_log_stream {
params.put(
&format!("{}{}", prefix, "CloudwatchLogStream"),
&field_value,
);
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ConnectionLogResponseOptions {
pub cloudwatch_log_group: Option<String>,
pub cloudwatch_log_stream: Option<String>,
pub enabled: Option<bool>,
}
struct ConnectionLogResponseOptionsDeserializer;
impl ConnectionLogResponseOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ConnectionLogResponseOptions, XmlParseError> {
deserialize_elements::<_, ConnectionLogResponseOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CloudwatchLogGroup" => {
obj.cloudwatch_log_group = Some(StringDeserializer::deserialize(
"CloudwatchLogGroup",
stack,
)?);
}
"CloudwatchLogStream" => {
obj.cloudwatch_log_stream = Some(StringDeserializer::deserialize(
"CloudwatchLogStream",
stack,
)?);
}
"Enabled" => {
obj.enabled = Some(BooleanDeserializer::deserialize("Enabled", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ConnectionNotification {
pub connection_events: Option<Vec<String>>,
pub connection_notification_arn: Option<String>,
pub connection_notification_id: Option<String>,
pub connection_notification_state: Option<String>,
pub connection_notification_type: Option<String>,
pub service_id: Option<String>,
pub vpc_endpoint_id: Option<String>,
}
struct ConnectionNotificationDeserializer;
impl ConnectionNotificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ConnectionNotification, XmlParseError> {
deserialize_elements::<_, ConnectionNotification, _>(tag_name, stack, |name, stack, obj| {
match name {
"connectionEvents" => {
obj.connection_events.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("connectionEvents", stack)?,
);
}
"connectionNotificationArn" => {
obj.connection_notification_arn = Some(StringDeserializer::deserialize(
"connectionNotificationArn",
stack,
)?);
}
"connectionNotificationId" => {
obj.connection_notification_id = Some(StringDeserializer::deserialize(
"connectionNotificationId",
stack,
)?);
}
"connectionNotificationState" => {
obj.connection_notification_state =
Some(ConnectionNotificationStateDeserializer::deserialize(
"connectionNotificationState",
stack,
)?);
}
"connectionNotificationType" => {
obj.connection_notification_type =
Some(ConnectionNotificationTypeDeserializer::deserialize(
"connectionNotificationType",
stack,
)?);
}
"serviceId" => {
obj.service_id = Some(StringDeserializer::deserialize("serviceId", stack)?);
}
"vpcEndpointId" => {
obj.vpc_endpoint_id =
Some(StringDeserializer::deserialize("vpcEndpointId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ConnectionNotificationSetDeserializer;
impl ConnectionNotificationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ConnectionNotification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ConnectionNotificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ConnectionNotificationStateDeserializer;
impl ConnectionNotificationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ConnectionNotificationTypeDeserializer;
impl ConnectionNotificationTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ContainerFormatDeserializer;
impl ContainerFormatDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ConversionIdStringListSerializer;
impl ConversionIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ConversionTask {
pub conversion_task_id: Option<String>,
pub expiration_time: Option<String>,
pub import_instance: Option<ImportInstanceTaskDetails>,
pub import_volume: Option<ImportVolumeTaskDetails>,
pub state: Option<String>,
pub status_message: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct ConversionTaskDeserializer;
impl ConversionTaskDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ConversionTask, XmlParseError> {
deserialize_elements::<_, ConversionTask, _>(tag_name, stack, |name, stack, obj| {
match name {
"conversionTaskId" => {
obj.conversion_task_id =
Some(StringDeserializer::deserialize("conversionTaskId", stack)?);
}
"expirationTime" => {
obj.expiration_time =
Some(StringDeserializer::deserialize("expirationTime", stack)?);
}
"importInstance" => {
obj.import_instance = Some(ImportInstanceTaskDetailsDeserializer::deserialize(
"importInstance",
stack,
)?);
}
"importVolume" => {
obj.import_volume = Some(ImportVolumeTaskDetailsDeserializer::deserialize(
"importVolume",
stack,
)?);
}
"state" => {
obj.state = Some(ConversionTaskStateDeserializer::deserialize(
"state", stack,
)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ConversionTaskStateDeserializer;
impl ConversionTaskStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyFpgaImageRequest {
pub client_token: Option<String>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub name: Option<String>,
pub source_fpga_image_id: String,
pub source_region: String,
}
struct CopyFpgaImageRequestSerializer;
impl CopyFpgaImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopyFpgaImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SourceFpgaImageId"),
&obj.source_fpga_image_id,
);
params.put(&format!("{}{}", prefix, "SourceRegion"), &obj.source_region);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyFpgaImageResult {
pub fpga_image_id: Option<String>,
}
struct CopyFpgaImageResultDeserializer;
impl CopyFpgaImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyFpgaImageResult, XmlParseError> {
deserialize_elements::<_, CopyFpgaImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"fpgaImageId" => {
obj.fpga_image_id =
Some(StringDeserializer::deserialize("fpgaImageId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyImageRequest {
pub client_token: Option<String>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub encrypted: Option<bool>,
pub kms_key_id: Option<String>,
pub name: String,
pub source_image_id: String,
pub source_region: String,
}
struct CopyImageRequestSerializer;
impl CopyImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopyImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
params.put(
&format!("{}{}", prefix, "SourceImageId"),
&obj.source_image_id,
);
params.put(&format!("{}{}", prefix, "SourceRegion"), &obj.source_region);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyImageResult {
pub image_id: Option<String>,
}
struct CopyImageResultDeserializer;
impl CopyImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyImageResult, XmlParseError> {
deserialize_elements::<_, CopyImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopySnapshotRequest {
pub description: Option<String>,
pub destination_region: Option<String>,
pub dry_run: Option<bool>,
pub encrypted: Option<bool>,
pub kms_key_id: Option<String>,
pub presigned_url: Option<String>,
pub source_region: String,
pub source_snapshot_id: String,
}
struct CopySnapshotRequestSerializer;
impl CopySnapshotRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopySnapshotRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.destination_region {
params.put(&format!("{}{}", prefix, "DestinationRegion"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.presigned_url {
params.put(&format!("{}{}", prefix, "PresignedUrl"), &field_value);
}
params.put(&format!("{}{}", prefix, "SourceRegion"), &obj.source_region);
params.put(
&format!("{}{}", prefix, "SourceSnapshotId"),
&obj.source_snapshot_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopySnapshotResult {
pub snapshot_id: Option<String>,
}
struct CopySnapshotResultDeserializer;
impl CopySnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopySnapshotResult, XmlParseError> {
deserialize_elements::<_, CopySnapshotResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CpuOptions {
pub core_count: Option<i64>,
pub threads_per_core: Option<i64>,
}
struct CpuOptionsDeserializer;
impl CpuOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CpuOptions, XmlParseError> {
deserialize_elements::<_, CpuOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"coreCount" => {
obj.core_count = Some(IntegerDeserializer::deserialize("coreCount", stack)?);
}
"threadsPerCore" => {
obj.threads_per_core =
Some(IntegerDeserializer::deserialize("threadsPerCore", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CpuOptionsRequest {
pub core_count: Option<i64>,
pub threads_per_core: Option<i64>,
}
struct CpuOptionsRequestSerializer;
impl CpuOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CpuOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.core_count {
params.put(&format!("{}{}", prefix, "CoreCount"), &field_value);
}
if let Some(ref field_value) = obj.threads_per_core {
params.put(&format!("{}{}", prefix, "ThreadsPerCore"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateCapacityReservationRequest {
pub availability_zone: String,
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub ebs_optimized: Option<bool>,
pub end_date: Option<String>,
pub end_date_type: Option<String>,
pub ephemeral_storage: Option<bool>,
pub instance_count: i64,
pub instance_match_criteria: Option<String>,
pub instance_platform: String,
pub instance_type: String,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub tenancy: Option<String>,
}
struct CreateCapacityReservationRequestSerializer;
impl CreateCapacityReservationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateCapacityReservationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AvailabilityZone"),
&obj.availability_zone,
);
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(&format!("{}{}", prefix, "EbsOptimized"), &field_value);
}
if let Some(ref field_value) = obj.end_date {
params.put(&format!("{}{}", prefix, "EndDate"), &field_value);
}
if let Some(ref field_value) = obj.end_date_type {
params.put(&format!("{}{}", prefix, "EndDateType"), &field_value);
}
if let Some(ref field_value) = obj.ephemeral_storage {
params.put(&format!("{}{}", prefix, "EphemeralStorage"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InstanceCount"),
&obj.instance_count,
);
if let Some(ref field_value) = obj.instance_match_criteria {
params.put(
&format!("{}{}", prefix, "InstanceMatchCriteria"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "InstancePlatform"),
&obj.instance_platform,
);
params.put(&format!("{}{}", prefix, "InstanceType"), &obj.instance_type);
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecifications"),
field_value,
);
}
if let Some(ref field_value) = obj.tenancy {
params.put(&format!("{}{}", prefix, "Tenancy"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateCapacityReservationResult {
pub capacity_reservation: Option<CapacityReservation>,
}
struct CreateCapacityReservationResultDeserializer;
impl CreateCapacityReservationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCapacityReservationResult, XmlParseError> {
deserialize_elements::<_, CreateCapacityReservationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"capacityReservation" => {
obj.capacity_reservation =
Some(CapacityReservationDeserializer::deserialize(
"capacityReservation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateClientVpnEndpointRequest {
pub authentication_options: Vec<ClientVpnAuthenticationRequest>,
pub client_cidr_block: String,
pub client_token: Option<String>,
pub connection_log_options: ConnectionLogOptions,
pub description: Option<String>,
pub dns_servers: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub server_certificate_arn: String,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub transport_protocol: Option<String>,
}
struct CreateClientVpnEndpointRequestSerializer;
impl CreateClientVpnEndpointRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClientVpnEndpointRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
ClientVpnAuthenticationRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "Authentication"),
&obj.authentication_options,
);
params.put(
&format!("{}{}", prefix, "ClientCidrBlock"),
&obj.client_cidr_block,
);
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
ConnectionLogOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "ConnectionLogOptions"),
&obj.connection_log_options,
);
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dns_servers {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "DnsServers"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ServerCertificateArn"),
&obj.server_certificate_arn,
);
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.transport_protocol {
params.put(&format!("{}{}", prefix, "TransportProtocol"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateClientVpnEndpointResult {
pub client_vpn_endpoint_id: Option<String>,
pub dns_name: Option<String>,
pub status: Option<ClientVpnEndpointStatus>,
}
struct CreateClientVpnEndpointResultDeserializer;
impl CreateClientVpnEndpointResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClientVpnEndpointResult, XmlParseError> {
deserialize_elements::<_, CreateClientVpnEndpointResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"dnsName" => {
obj.dns_name = Some(StringDeserializer::deserialize("dnsName", stack)?);
}
"status" => {
obj.status = Some(ClientVpnEndpointStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateClientVpnRouteRequest {
pub client_token: Option<String>,
pub client_vpn_endpoint_id: String,
pub description: Option<String>,
pub destination_cidr_block: String,
pub dry_run: Option<bool>,
pub target_vpc_subnet_id: String,
}
struct CreateClientVpnRouteRequestSerializer;
impl CreateClientVpnRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClientVpnRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TargetVpcSubnetId"),
&obj.target_vpc_subnet_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateClientVpnRouteResult {
pub status: Option<ClientVpnRouteStatus>,
}
struct CreateClientVpnRouteResultDeserializer;
impl CreateClientVpnRouteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClientVpnRouteResult, XmlParseError> {
deserialize_elements::<_, CreateClientVpnRouteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"status" => {
obj.status = Some(ClientVpnRouteStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateCustomerGatewayRequest {
pub bgp_asn: i64,
pub dry_run: Option<bool>,
pub public_ip: String,
pub type_: String,
}
struct CreateCustomerGatewayRequestSerializer;
impl CreateCustomerGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateCustomerGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "BgpAsn"), &obj.bgp_asn);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "IpAddress"), &obj.public_ip);
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateCustomerGatewayResult {
pub customer_gateway: Option<CustomerGateway>,
}
struct CreateCustomerGatewayResultDeserializer;
impl CreateCustomerGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCustomerGatewayResult, XmlParseError> {
deserialize_elements::<_, CreateCustomerGatewayResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"customerGateway" => {
obj.customer_gateway = Some(CustomerGatewayDeserializer::deserialize(
"customerGateway",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDefaultSubnetRequest {
pub availability_zone: String,
pub dry_run: Option<bool>,
}
struct CreateDefaultSubnetRequestSerializer;
impl CreateDefaultSubnetRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDefaultSubnetRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AvailabilityZone"),
&obj.availability_zone,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDefaultSubnetResult {
pub subnet: Option<Subnet>,
}
struct CreateDefaultSubnetResultDeserializer;
impl CreateDefaultSubnetResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDefaultSubnetResult, XmlParseError> {
deserialize_elements::<_, CreateDefaultSubnetResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"subnet" => {
obj.subnet = Some(SubnetDeserializer::deserialize("subnet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDefaultVpcRequest {
pub dry_run: Option<bool>,
}
struct CreateDefaultVpcRequestSerializer;
impl CreateDefaultVpcRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDefaultVpcRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDefaultVpcResult {
pub vpc: Option<Vpc>,
}
struct CreateDefaultVpcResultDeserializer;
impl CreateDefaultVpcResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDefaultVpcResult, XmlParseError> {
deserialize_elements::<_, CreateDefaultVpcResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"vpc" => {
obj.vpc = Some(VpcDeserializer::deserialize("vpc", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDhcpOptionsRequest {
pub dhcp_configurations: Vec<NewDhcpConfiguration>,
pub dry_run: Option<bool>,
}
struct CreateDhcpOptionsRequestSerializer;
impl CreateDhcpOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDhcpOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
NewDhcpConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "DhcpConfiguration"),
&obj.dhcp_configurations,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDhcpOptionsResult {
pub dhcp_options: Option<DhcpOptions>,
}
struct CreateDhcpOptionsResultDeserializer;
impl CreateDhcpOptionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDhcpOptionsResult, XmlParseError> {
deserialize_elements::<_, CreateDhcpOptionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"dhcpOptions" => {
obj.dhcp_options =
Some(DhcpOptionsDeserializer::deserialize("dhcpOptions", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateEgressOnlyInternetGatewayRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct CreateEgressOnlyInternetGatewayRequestSerializer;
impl CreateEgressOnlyInternetGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateEgressOnlyInternetGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateEgressOnlyInternetGatewayResult {
pub client_token: Option<String>,
pub egress_only_internet_gateway: Option<EgressOnlyInternetGateway>,
}
struct CreateEgressOnlyInternetGatewayResultDeserializer;
impl CreateEgressOnlyInternetGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateEgressOnlyInternetGatewayResult, XmlParseError> {
deserialize_elements::<_, CreateEgressOnlyInternetGatewayResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"egressOnlyInternetGateway" => {
obj.egress_only_internet_gateway =
Some(EgressOnlyInternetGatewayDeserializer::deserialize(
"egressOnlyInternetGateway",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EC2CreateFleetError {
pub error_code: Option<String>,
pub error_message: Option<String>,
pub launch_template_and_overrides: Option<LaunchTemplateAndOverridesResponse>,
pub lifecycle: Option<String>,
}
struct EC2CreateFleetErrorDeserializer;
impl EC2CreateFleetErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EC2CreateFleetError, XmlParseError> {
deserialize_elements::<_, EC2CreateFleetError, _>(tag_name, stack, |name, stack, obj| {
match name {
"errorCode" => {
obj.error_code = Some(StringDeserializer::deserialize("errorCode", stack)?);
}
"errorMessage" => {
obj.error_message =
Some(StringDeserializer::deserialize("errorMessage", stack)?);
}
"launchTemplateAndOverrides" => {
obj.launch_template_and_overrides =
Some(LaunchTemplateAndOverridesResponseDeserializer::deserialize(
"launchTemplateAndOverrides",
stack,
)?);
}
"lifecycle" => {
obj.lifecycle = Some(InstanceLifecycleDeserializer::deserialize(
"lifecycle",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CreateFleetErrorsSetDeserializer;
impl CreateFleetErrorsSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EC2CreateFleetError>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(EC2CreateFleetErrorDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFleetInstance {
pub instance_ids: Option<Vec<String>>,
pub instance_type: Option<String>,
pub launch_template_and_overrides: Option<LaunchTemplateAndOverridesResponse>,
pub lifecycle: Option<String>,
pub platform: Option<String>,
}
struct CreateFleetInstanceDeserializer;
impl CreateFleetInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateFleetInstance, XmlParseError> {
deserialize_elements::<_, CreateFleetInstance, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceIds" => {
obj.instance_ids.get_or_insert(vec![]).extend(
InstanceIdsSetDeserializer::deserialize("instanceIds", stack)?,
);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"launchTemplateAndOverrides" => {
obj.launch_template_and_overrides =
Some(LaunchTemplateAndOverridesResponseDeserializer::deserialize(
"launchTemplateAndOverrides",
stack,
)?);
}
"lifecycle" => {
obj.lifecycle = Some(InstanceLifecycleDeserializer::deserialize(
"lifecycle",
stack,
)?);
}
"platform" => {
obj.platform =
Some(PlatformValuesDeserializer::deserialize("platform", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CreateFleetInstancesSetDeserializer;
impl CreateFleetInstancesSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CreateFleetInstance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CreateFleetInstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFleetRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub excess_capacity_termination_policy: Option<String>,
pub launch_template_configs: Vec<FleetLaunchTemplateConfigRequest>,
pub on_demand_options: Option<OnDemandOptionsRequest>,
pub replace_unhealthy_instances: Option<bool>,
pub spot_options: Option<SpotOptionsRequest>,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub target_capacity_specification: TargetCapacitySpecificationRequest,
pub terminate_instances_with_expiration: Option<bool>,
pub type_: Option<String>,
pub valid_from: Option<String>,
pub valid_until: Option<String>,
}
struct CreateFleetRequestSerializer;
impl CreateFleetRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateFleetRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.excess_capacity_termination_policy {
params.put(
&format!("{}{}", prefix, "ExcessCapacityTerminationPolicy"),
&field_value,
);
}
FleetLaunchTemplateConfigListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateConfigs"),
&obj.launch_template_configs,
);
if let Some(ref field_value) = obj.on_demand_options {
OnDemandOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "OnDemandOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.replace_unhealthy_instances {
params.put(
&format!("{}{}", prefix, "ReplaceUnhealthyInstances"),
&field_value,
);
}
if let Some(ref field_value) = obj.spot_options {
SpotOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
TargetCapacitySpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetCapacitySpecification"),
&obj.target_capacity_specification,
);
if let Some(ref field_value) = obj.terminate_instances_with_expiration {
params.put(
&format!("{}{}", prefix, "TerminateInstancesWithExpiration"),
&field_value,
);
}
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.valid_from {
params.put(&format!("{}{}", prefix, "ValidFrom"), &field_value);
}
if let Some(ref field_value) = obj.valid_until {
params.put(&format!("{}{}", prefix, "ValidUntil"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFleetResult {
pub errors: Option<Vec<EC2CreateFleetError>>,
pub fleet_id: Option<String>,
pub instances: Option<Vec<CreateFleetInstance>>,
}
struct CreateFleetResultDeserializer;
impl CreateFleetResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateFleetResult, XmlParseError> {
deserialize_elements::<_, CreateFleetResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"errorSet" => {
obj.errors.get_or_insert(vec![]).extend(
CreateFleetErrorsSetDeserializer::deserialize("errorSet", stack)?,
);
}
"fleetId" => {
obj.fleet_id =
Some(FleetIdentifierDeserializer::deserialize("fleetId", stack)?);
}
"fleetInstanceSet" => {
obj.instances.get_or_insert(vec![]).extend(
CreateFleetInstancesSetDeserializer::deserialize(
"fleetInstanceSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFlowLogsRequest {
pub client_token: Option<String>,
pub deliver_logs_permission_arn: Option<String>,
pub dry_run: Option<bool>,
pub log_destination: Option<String>,
pub log_destination_type: Option<String>,
pub log_group_name: Option<String>,
pub resource_ids: Vec<String>,
pub resource_type: String,
pub traffic_type: String,
}
struct CreateFlowLogsRequestSerializer;
impl CreateFlowLogsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateFlowLogsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.deliver_logs_permission_arn {
params.put(
&format!("{}{}", prefix, "DeliverLogsPermissionArn"),
&field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.log_destination {
params.put(&format!("{}{}", prefix, "LogDestination"), &field_value);
}
if let Some(ref field_value) = obj.log_destination_type {
params.put(&format!("{}{}", prefix, "LogDestinationType"), &field_value);
}
if let Some(ref field_value) = obj.log_group_name {
params.put(&format!("{}{}", prefix, "LogGroupName"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceId"),
&obj.resource_ids,
);
params.put(&format!("{}{}", prefix, "ResourceType"), &obj.resource_type);
params.put(&format!("{}{}", prefix, "TrafficType"), &obj.traffic_type);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFlowLogsResult {
pub client_token: Option<String>,
pub flow_log_ids: Option<Vec<String>>,
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct CreateFlowLogsResultDeserializer;
impl CreateFlowLogsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateFlowLogsResult, XmlParseError> {
deserialize_elements::<_, CreateFlowLogsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"clientToken" => {
obj.client_token = Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"flowLogIdSet" => {
obj.flow_log_ids.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("flowLogIdSet", stack)?,
);
}
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFpgaImageRequest {
pub client_token: Option<String>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub input_storage_location: StorageLocation,
pub logs_storage_location: Option<StorageLocation>,
pub name: Option<String>,
}
struct CreateFpgaImageRequestSerializer;
impl CreateFpgaImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateFpgaImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
StorageLocationSerializer::serialize(
params,
&format!("{}{}", prefix, "InputStorageLocation"),
&obj.input_storage_location,
);
if let Some(ref field_value) = obj.logs_storage_location {
StorageLocationSerializer::serialize(
params,
&format!("{}{}", prefix, "LogsStorageLocation"),
field_value,
);
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateFpgaImageResult {
pub fpga_image_global_id: Option<String>,
pub fpga_image_id: Option<String>,
}
struct CreateFpgaImageResultDeserializer;
impl CreateFpgaImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateFpgaImageResult, XmlParseError> {
deserialize_elements::<_, CreateFpgaImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"fpgaImageGlobalId" => {
obj.fpga_image_global_id =
Some(StringDeserializer::deserialize("fpgaImageGlobalId", stack)?);
}
"fpgaImageId" => {
obj.fpga_image_id =
Some(StringDeserializer::deserialize("fpgaImageId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateImageRequest {
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub instance_id: String,
pub name: String,
pub no_reboot: Option<bool>,
}
struct CreateImageRequestSerializer;
impl CreateImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.block_device_mappings {
BlockDeviceMappingRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
if let Some(ref field_value) = obj.no_reboot {
params.put(&format!("{}{}", prefix, "NoReboot"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateImageResult {
pub image_id: Option<String>,
}
struct CreateImageResultDeserializer;
impl CreateImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateImageResult, XmlParseError> {
deserialize_elements::<_, CreateImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateInstanceExportTaskRequest {
pub description: Option<String>,
pub export_to_s3_task: Option<ExportToS3TaskSpecification>,
pub instance_id: String,
pub target_environment: Option<String>,
}
struct CreateInstanceExportTaskRequestSerializer;
impl CreateInstanceExportTaskRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateInstanceExportTaskRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.export_to_s3_task {
ExportToS3TaskSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "ExportToS3"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
if let Some(ref field_value) = obj.target_environment {
params.put(&format!("{}{}", prefix, "TargetEnvironment"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateInstanceExportTaskResult {
pub export_task: Option<ExportTask>,
}
struct CreateInstanceExportTaskResultDeserializer;
impl CreateInstanceExportTaskResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateInstanceExportTaskResult, XmlParseError> {
deserialize_elements::<_, CreateInstanceExportTaskResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"exportTask" => {
obj.export_task =
Some(ExportTaskDeserializer::deserialize("exportTask", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateInternetGatewayRequest {
pub dry_run: Option<bool>,
}
struct CreateInternetGatewayRequestSerializer;
impl CreateInternetGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateInternetGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateInternetGatewayResult {
pub internet_gateway: Option<InternetGateway>,
}
struct CreateInternetGatewayResultDeserializer;
impl CreateInternetGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateInternetGatewayResult, XmlParseError> {
deserialize_elements::<_, CreateInternetGatewayResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"internetGateway" => {
obj.internet_gateway = Some(InternetGatewayDeserializer::deserialize(
"internetGateway",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateKeyPairRequest {
pub dry_run: Option<bool>,
pub key_name: String,
}
struct CreateKeyPairRequestSerializer;
impl CreateKeyPairRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateKeyPairRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "KeyName"), &obj.key_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateLaunchTemplateRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub launch_template_data: RequestLaunchTemplateData,
pub launch_template_name: String,
pub version_description: Option<String>,
}
struct CreateLaunchTemplateRequestSerializer;
impl CreateLaunchTemplateRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateLaunchTemplateRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
RequestLaunchTemplateDataSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateData"),
&obj.launch_template_data,
);
params.put(
&format!("{}{}", prefix, "LaunchTemplateName"),
&obj.launch_template_name,
);
if let Some(ref field_value) = obj.version_description {
params.put(&format!("{}{}", prefix, "VersionDescription"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateLaunchTemplateResult {
pub launch_template: Option<LaunchTemplate>,
}
struct CreateLaunchTemplateResultDeserializer;
impl CreateLaunchTemplateResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateLaunchTemplateResult, XmlParseError> {
deserialize_elements::<_, CreateLaunchTemplateResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplate" => {
obj.launch_template = Some(LaunchTemplateDeserializer::deserialize(
"launchTemplate",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateLaunchTemplateVersionRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub launch_template_data: RequestLaunchTemplateData,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub source_version: Option<String>,
pub version_description: Option<String>,
}
struct CreateLaunchTemplateVersionRequestSerializer;
impl CreateLaunchTemplateVersionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateLaunchTemplateVersionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
RequestLaunchTemplateDataSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateData"),
&obj.launch_template_data,
);
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
if let Some(ref field_value) = obj.source_version {
params.put(&format!("{}{}", prefix, "SourceVersion"), &field_value);
}
if let Some(ref field_value) = obj.version_description {
params.put(&format!("{}{}", prefix, "VersionDescription"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateLaunchTemplateVersionResult {
pub launch_template_version: Option<LaunchTemplateVersion>,
}
struct CreateLaunchTemplateVersionResultDeserializer;
impl CreateLaunchTemplateVersionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateLaunchTemplateVersionResult, XmlParseError> {
deserialize_elements::<_, CreateLaunchTemplateVersionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateVersion" => {
obj.launch_template_version =
Some(LaunchTemplateVersionDeserializer::deserialize(
"launchTemplateVersion",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNatGatewayRequest {
pub allocation_id: String,
pub client_token: Option<String>,
pub subnet_id: String,
}
struct CreateNatGatewayRequestSerializer;
impl CreateNatGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateNatGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "AllocationId"), &obj.allocation_id);
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNatGatewayResult {
pub client_token: Option<String>,
pub nat_gateway: Option<NatGateway>,
}
struct CreateNatGatewayResultDeserializer;
impl CreateNatGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateNatGatewayResult, XmlParseError> {
deserialize_elements::<_, CreateNatGatewayResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"clientToken" => {
obj.client_token = Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"natGateway" => {
obj.nat_gateway =
Some(NatGatewayDeserializer::deserialize("natGateway", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkAclEntryRequest {
pub cidr_block: Option<String>,
pub dry_run: Option<bool>,
pub egress: bool,
pub icmp_type_code: Option<IcmpTypeCode>,
pub ipv_6_cidr_block: Option<String>,
pub network_acl_id: String,
pub port_range: Option<PortRange>,
pub protocol: String,
pub rule_action: String,
pub rule_number: i64,
}
struct CreateNetworkAclEntryRequestSerializer;
impl CreateNetworkAclEntryRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateNetworkAclEntryRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_block {
params.put(&format!("{}{}", prefix, "CidrBlock"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "Egress"), &obj.egress);
if let Some(ref field_value) = obj.icmp_type_code {
IcmpTypeCodeSerializer::serialize(
params,
&format!("{}{}", prefix, "Icmp"),
field_value,
);
}
if let Some(ref field_value) = obj.ipv_6_cidr_block {
params.put(&format!("{}{}", prefix, "Ipv6CidrBlock"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkAclId"),
&obj.network_acl_id,
);
if let Some(ref field_value) = obj.port_range {
PortRangeSerializer::serialize(
params,
&format!("{}{}", prefix, "PortRange"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "Protocol"), &obj.protocol);
params.put(&format!("{}{}", prefix, "RuleAction"), &obj.rule_action);
params.put(&format!("{}{}", prefix, "RuleNumber"), &obj.rule_number);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkAclRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct CreateNetworkAclRequestSerializer;
impl CreateNetworkAclRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateNetworkAclRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkAclResult {
pub network_acl: Option<NetworkAcl>,
}
struct CreateNetworkAclResultDeserializer;
impl CreateNetworkAclResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateNetworkAclResult, XmlParseError> {
deserialize_elements::<_, CreateNetworkAclResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"networkAcl" => {
obj.network_acl =
Some(NetworkAclDeserializer::deserialize("networkAcl", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkInterfacePermissionRequest {
pub aws_account_id: Option<String>,
pub aws_service: Option<String>,
pub dry_run: Option<bool>,
pub network_interface_id: String,
pub permission: String,
}
struct CreateNetworkInterfacePermissionRequestSerializer;
impl CreateNetworkInterfacePermissionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateNetworkInterfacePermissionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.aws_account_id {
params.put(&format!("{}{}", prefix, "AwsAccountId"), &field_value);
}
if let Some(ref field_value) = obj.aws_service {
params.put(&format!("{}{}", prefix, "AwsService"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
params.put(&format!("{}{}", prefix, "Permission"), &obj.permission);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkInterfacePermissionResult {
pub interface_permission: Option<NetworkInterfacePermission>,
}
struct CreateNetworkInterfacePermissionResultDeserializer;
impl CreateNetworkInterfacePermissionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateNetworkInterfacePermissionResult, XmlParseError> {
deserialize_elements::<_, CreateNetworkInterfacePermissionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"interfacePermission" => {
obj.interface_permission =
Some(NetworkInterfacePermissionDeserializer::deserialize(
"interfacePermission",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkInterfaceRequest {
pub description: Option<String>,
pub dry_run: Option<bool>,
pub groups: Option<Vec<String>>,
pub interface_type: Option<String>,
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<InstanceIpv6Address>>,
pub private_ip_address: Option<String>,
pub private_ip_addresses: Option<Vec<PrivateIpAddressSpecification>>,
pub secondary_private_ip_address_count: Option<i64>,
pub subnet_id: String,
}
struct CreateNetworkInterfaceRequestSerializer;
impl CreateNetworkInterfaceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateNetworkInterfaceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.groups {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.interface_type {
params.put(&format!("{}{}", prefix, "InterfaceType"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_address_count {
params.put(&format!("{}{}", prefix, "Ipv6AddressCount"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_addresses {
InstanceIpv6AddressListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Addresses"),
field_value,
);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_addresses {
PrivateIpAddressSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrivateIpAddresses"),
field_value,
);
}
if let Some(ref field_value) = obj.secondary_private_ip_address_count {
params.put(
&format!("{}{}", prefix, "SecondaryPrivateIpAddressCount"),
&field_value,
);
}
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateNetworkInterfaceResult {
pub network_interface: Option<NetworkInterface>,
}
struct CreateNetworkInterfaceResultDeserializer;
impl CreateNetworkInterfaceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateNetworkInterfaceResult, XmlParseError> {
deserialize_elements::<_, CreateNetworkInterfaceResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"networkInterface" => {
obj.network_interface = Some(NetworkInterfaceDeserializer::deserialize(
"networkInterface",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreatePlacementGroupRequest {
pub dry_run: Option<bool>,
pub group_name: Option<String>,
pub partition_count: Option<i64>,
pub strategy: Option<String>,
}
struct CreatePlacementGroupRequestSerializer;
impl CreatePlacementGroupRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreatePlacementGroupRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.partition_count {
params.put(&format!("{}{}", prefix, "PartitionCount"), &field_value);
}
if let Some(ref field_value) = obj.strategy {
params.put(&format!("{}{}", prefix, "Strategy"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateReservedInstancesListingRequest {
pub client_token: String,
pub instance_count: i64,
pub price_schedules: Vec<PriceScheduleSpecification>,
pub reserved_instances_id: String,
}
struct CreateReservedInstancesListingRequestSerializer;
impl CreateReservedInstancesListingRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateReservedInstancesListingRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ClientToken"), &obj.client_token);
params.put(
&format!("{}{}", prefix, "InstanceCount"),
&obj.instance_count,
);
PriceScheduleSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "PriceSchedules"),
&obj.price_schedules,
);
params.put(
&format!("{}{}", prefix, "ReservedInstancesId"),
&obj.reserved_instances_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateReservedInstancesListingResult {
pub reserved_instances_listings: Option<Vec<ReservedInstancesListing>>,
}
struct CreateReservedInstancesListingResultDeserializer;
impl CreateReservedInstancesListingResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateReservedInstancesListingResult, XmlParseError> {
deserialize_elements::<_, CreateReservedInstancesListingResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesListingsSet" => {
obj.reserved_instances_listings
.get_or_insert(vec![])
.extend(ReservedInstancesListingListDeserializer::deserialize(
"reservedInstancesListingsSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateRouteRequest {
pub destination_cidr_block: Option<String>,
pub destination_ipv_6_cidr_block: Option<String>,
pub dry_run: Option<bool>,
pub egress_only_internet_gateway_id: Option<String>,
pub gateway_id: Option<String>,
pub instance_id: Option<String>,
pub nat_gateway_id: Option<String>,
pub network_interface_id: Option<String>,
pub route_table_id: String,
pub transit_gateway_id: Option<String>,
pub vpc_peering_connection_id: Option<String>,
}
struct CreateRouteRequestSerializer;
impl CreateRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.destination_cidr_block {
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.destination_ipv_6_cidr_block {
params.put(
&format!("{}{}", prefix, "DestinationIpv6CidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.egress_only_internet_gateway_id {
params.put(
&format!("{}{}", prefix, "EgressOnlyInternetGatewayId"),
&field_value,
);
}
if let Some(ref field_value) = obj.gateway_id {
params.put(&format!("{}{}", prefix, "GatewayId"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
if let Some(ref field_value) = obj.nat_gateway_id {
params.put(&format!("{}{}", prefix, "NatGatewayId"), &field_value);
}
if let Some(ref field_value) = obj.network_interface_id {
params.put(&format!("{}{}", prefix, "NetworkInterfaceId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
if let Some(ref field_value) = obj.transit_gateway_id {
params.put(&format!("{}{}", prefix, "TransitGatewayId"), &field_value);
}
if let Some(ref field_value) = obj.vpc_peering_connection_id {
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateRouteResult {
pub return_: Option<bool>,
}
struct CreateRouteResultDeserializer;
impl CreateRouteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateRouteResult, XmlParseError> {
deserialize_elements::<_, CreateRouteResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateRouteTableRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct CreateRouteTableRequestSerializer;
impl CreateRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateRouteTableResult {
pub route_table: Option<RouteTable>,
}
struct CreateRouteTableResultDeserializer;
impl CreateRouteTableResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateRouteTableResult, XmlParseError> {
deserialize_elements::<_, CreateRouteTableResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"routeTable" => {
obj.route_table =
Some(RouteTableDeserializer::deserialize("routeTable", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSecurityGroupRequest {
pub description: String,
pub dry_run: Option<bool>,
pub group_name: String,
pub vpc_id: Option<String>,
}
struct CreateSecurityGroupRequestSerializer;
impl CreateSecurityGroupRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSecurityGroupRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "GroupDescription"),
&obj.description,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "GroupName"), &obj.group_name);
if let Some(ref field_value) = obj.vpc_id {
params.put(&format!("{}{}", prefix, "VpcId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSecurityGroupResult {
pub group_id: Option<String>,
}
struct CreateSecurityGroupResultDeserializer;
impl CreateSecurityGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSecurityGroupResult, XmlParseError> {
deserialize_elements::<_, CreateSecurityGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSnapshotRequest {
pub description: Option<String>,
pub dry_run: Option<bool>,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub volume_id: String,
}
struct CreateSnapshotRequestSerializer;
impl CreateSnapshotRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSnapshotRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSnapshotsRequest {
pub copy_tags_from_source: Option<String>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub instance_specification: InstanceSpecification,
pub tag_specifications: Option<Vec<TagSpecification>>,
}
struct CreateSnapshotsRequestSerializer;
impl CreateSnapshotsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSnapshotsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.copy_tags_from_source {
params.put(&format!("{}{}", prefix, "CopyTagsFromSource"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceSpecification"),
&obj.instance_specification,
);
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSnapshotsResult {
pub snapshots: Option<Vec<SnapshotInfo>>,
}
struct CreateSnapshotsResultDeserializer;
impl CreateSnapshotsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSnapshotsResult, XmlParseError> {
deserialize_elements::<_, CreateSnapshotsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"snapshotSet" => {
obj.snapshots
.get_or_insert(vec![])
.extend(SnapshotSetDeserializer::deserialize("snapshotSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSpotDatafeedSubscriptionRequest {
pub bucket: String,
pub dry_run: Option<bool>,
pub prefix: Option<String>,
}
struct CreateSpotDatafeedSubscriptionRequestSerializer;
impl CreateSpotDatafeedSubscriptionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSpotDatafeedSubscriptionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Bucket"), &obj.bucket);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.prefix {
params.put(&format!("{}{}", prefix, "Prefix"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSpotDatafeedSubscriptionResult {
pub spot_datafeed_subscription: Option<SpotDatafeedSubscription>,
}
struct CreateSpotDatafeedSubscriptionResultDeserializer;
impl CreateSpotDatafeedSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSpotDatafeedSubscriptionResult, XmlParseError> {
deserialize_elements::<_, CreateSpotDatafeedSubscriptionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"spotDatafeedSubscription" => {
obj.spot_datafeed_subscription =
Some(SpotDatafeedSubscriptionDeserializer::deserialize(
"spotDatafeedSubscription",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSubnetRequest {
pub availability_zone: Option<String>,
pub availability_zone_id: Option<String>,
pub cidr_block: String,
pub dry_run: Option<bool>,
pub ipv_6_cidr_block: Option<String>,
pub vpc_id: String,
}
struct CreateSubnetRequestSerializer;
impl CreateSubnetRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSubnetRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.availability_zone_id {
params.put(&format!("{}{}", prefix, "AvailabilityZoneId"), &field_value);
}
params.put(&format!("{}{}", prefix, "CidrBlock"), &obj.cidr_block);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_cidr_block {
params.put(&format!("{}{}", prefix, "Ipv6CidrBlock"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateSubnetResult {
pub subnet: Option<Subnet>,
}
struct CreateSubnetResultDeserializer;
impl CreateSubnetResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSubnetResult, XmlParseError> {
deserialize_elements::<_, CreateSubnetResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"subnet" => {
obj.subnet = Some(SubnetDeserializer::deserialize("subnet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTagsRequest {
pub dry_run: Option<bool>,
pub resources: Vec<String>,
pub tags: Vec<Tag>,
}
struct CreateTagsRequestSerializer;
impl CreateTagsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTagsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ResourceIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceId"),
&obj.resources,
);
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), &obj.tags);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayRequest {
pub description: Option<String>,
pub dry_run: Option<bool>,
pub options: Option<TransitGatewayRequestOptions>,
pub tag_specifications: Option<Vec<TagSpecification>>,
}
struct CreateTransitGatewayRequestSerializer;
impl CreateTransitGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTransitGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.options {
TransitGatewayRequestOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Options"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayResult {
pub transit_gateway: Option<TransitGateway>,
}
struct CreateTransitGatewayResultDeserializer;
impl CreateTransitGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTransitGatewayResult, XmlParseError> {
deserialize_elements::<_, CreateTransitGatewayResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGateway" => {
obj.transit_gateway = Some(TransitGatewayDeserializer::deserialize(
"transitGateway",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayRouteRequest {
pub blackhole: Option<bool>,
pub destination_cidr_block: String,
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: Option<String>,
pub transit_gateway_route_table_id: String,
}
struct CreateTransitGatewayRouteRequestSerializer;
impl CreateTransitGatewayRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTransitGatewayRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.blackhole {
params.put(&format!("{}{}", prefix, "Blackhole"), &field_value);
}
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_attachment_id {
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayRouteResult {
pub route: Option<TransitGatewayRoute>,
}
struct CreateTransitGatewayRouteResultDeserializer;
impl CreateTransitGatewayRouteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTransitGatewayRouteResult, XmlParseError> {
deserialize_elements::<_, CreateTransitGatewayRouteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"route" => {
obj.route = Some(TransitGatewayRouteDeserializer::deserialize(
"route", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayRouteTableRequest {
pub dry_run: Option<bool>,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub transit_gateway_id: String,
}
struct CreateTransitGatewayRouteTableRequestSerializer;
impl CreateTransitGatewayRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTransitGatewayRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecifications"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayId"),
&obj.transit_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayRouteTableResult {
pub transit_gateway_route_table: Option<TransitGatewayRouteTable>,
}
struct CreateTransitGatewayRouteTableResultDeserializer;
impl CreateTransitGatewayRouteTableResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTransitGatewayRouteTableResult, XmlParseError> {
deserialize_elements::<_, CreateTransitGatewayRouteTableResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayRouteTable" => {
obj.transit_gateway_route_table =
Some(TransitGatewayRouteTableDeserializer::deserialize(
"transitGatewayRouteTable",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayVpcAttachmentRequest {
pub dry_run: Option<bool>,
pub options: Option<CreateTransitGatewayVpcAttachmentRequestOptions>,
pub subnet_ids: Vec<String>,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub transit_gateway_id: String,
pub vpc_id: String,
}
struct CreateTransitGatewayVpcAttachmentRequestSerializer;
impl CreateTransitGatewayVpcAttachmentRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTransitGatewayVpcAttachmentRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.options {
CreateTransitGatewayVpcAttachmentRequestOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Options"),
field_value,
);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetIds"),
&obj.subnet_ids,
);
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecifications"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayId"),
&obj.transit_gateway_id,
);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayVpcAttachmentRequestOptions {
pub dns_support: Option<String>,
pub ipv_6_support: Option<String>,
}
struct CreateTransitGatewayVpcAttachmentRequestOptionsSerializer;
impl CreateTransitGatewayVpcAttachmentRequestOptionsSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &CreateTransitGatewayVpcAttachmentRequestOptions,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dns_support {
params.put(&format!("{}{}", prefix, "DnsSupport"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_support {
params.put(&format!("{}{}", prefix, "Ipv6Support"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTransitGatewayVpcAttachmentResult {
pub transit_gateway_vpc_attachment: Option<TransitGatewayVpcAttachment>,
}
struct CreateTransitGatewayVpcAttachmentResultDeserializer;
impl CreateTransitGatewayVpcAttachmentResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTransitGatewayVpcAttachmentResult, XmlParseError> {
deserialize_elements::<_, CreateTransitGatewayVpcAttachmentResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayVpcAttachment" => {
obj.transit_gateway_vpc_attachment =
Some(TransitGatewayVpcAttachmentDeserializer::deserialize(
"transitGatewayVpcAttachment",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVolumePermission {
pub group: Option<String>,
pub user_id: Option<String>,
}
struct CreateVolumePermissionDeserializer;
impl CreateVolumePermissionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVolumePermission, XmlParseError> {
deserialize_elements::<_, CreateVolumePermission, _>(tag_name, stack, |name, stack, obj| {
match name {
"group" => {
obj.group = Some(PermissionGroupDeserializer::deserialize("group", stack)?);
}
"userId" => {
obj.user_id = Some(StringDeserializer::deserialize("userId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CreateVolumePermissionSerializer;
impl CreateVolumePermissionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVolumePermission) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.group {
params.put(&format!("{}{}", prefix, "Group"), &field_value);
}
if let Some(ref field_value) = obj.user_id {
params.put(&format!("{}{}", prefix, "UserId"), &field_value);
}
}
}
struct CreateVolumePermissionListDeserializer;
impl CreateVolumePermissionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CreateVolumePermission>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CreateVolumePermissionDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct CreateVolumePermissionListSerializer;
impl CreateVolumePermissionListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<CreateVolumePermission>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
CreateVolumePermissionSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVolumePermissionModifications {
pub add: Option<Vec<CreateVolumePermission>>,
pub remove: Option<Vec<CreateVolumePermission>>,
}
struct CreateVolumePermissionModificationsSerializer;
impl CreateVolumePermissionModificationsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVolumePermissionModifications) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add {
CreateVolumePermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "Add"),
field_value,
);
}
if let Some(ref field_value) = obj.remove {
CreateVolumePermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "Remove"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVolumeRequest {
pub availability_zone: String,
pub dry_run: Option<bool>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub size: Option<i64>,
pub snapshot_id: Option<String>,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub volume_type: Option<String>,
}
struct CreateVolumeRequestSerializer;
impl CreateVolumeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVolumeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AvailabilityZone"),
&obj.availability_zone,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.size {
params.put(&format!("{}{}", prefix, "Size"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_id {
params.put(&format!("{}{}", prefix, "SnapshotId"), &field_value);
}
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.volume_type {
params.put(&format!("{}{}", prefix, "VolumeType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcEndpointConnectionNotificationRequest {
pub client_token: Option<String>,
pub connection_events: Vec<String>,
pub connection_notification_arn: String,
pub dry_run: Option<bool>,
pub service_id: Option<String>,
pub vpc_endpoint_id: Option<String>,
}
struct CreateVpcEndpointConnectionNotificationRequestSerializer;
impl CreateVpcEndpointConnectionNotificationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &CreateVpcEndpointConnectionNotificationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ConnectionEvents"),
&obj.connection_events,
);
params.put(
&format!("{}{}", prefix, "ConnectionNotificationArn"),
&obj.connection_notification_arn,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.service_id {
params.put(&format!("{}{}", prefix, "ServiceId"), &field_value);
}
if let Some(ref field_value) = obj.vpc_endpoint_id {
params.put(&format!("{}{}", prefix, "VpcEndpointId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcEndpointConnectionNotificationResult {
pub client_token: Option<String>,
pub connection_notification: Option<ConnectionNotification>,
}
struct CreateVpcEndpointConnectionNotificationResultDeserializer;
impl CreateVpcEndpointConnectionNotificationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpcEndpointConnectionNotificationResult, XmlParseError> {
deserialize_elements::<_, CreateVpcEndpointConnectionNotificationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"connectionNotification" => {
obj.connection_notification =
Some(ConnectionNotificationDeserializer::deserialize(
"connectionNotification",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcEndpointRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub policy_document: Option<String>,
pub private_dns_enabled: Option<bool>,
pub route_table_ids: Option<Vec<String>>,
pub security_group_ids: Option<Vec<String>>,
pub service_name: String,
pub subnet_ids: Option<Vec<String>>,
pub vpc_endpoint_type: Option<String>,
pub vpc_id: String,
}
struct CreateVpcEndpointRequestSerializer;
impl CreateVpcEndpointRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVpcEndpointRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.policy_document {
params.put(&format!("{}{}", prefix, "PolicyDocument"), &field_value);
}
if let Some(ref field_value) = obj.private_dns_enabled {
params.put(&format!("{}{}", prefix, "PrivateDnsEnabled"), &field_value);
}
if let Some(ref field_value) = obj.route_table_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RouteTableId"),
field_value,
);
}
if let Some(ref field_value) = obj.security_group_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "ServiceName"), &obj.service_name);
if let Some(ref field_value) = obj.subnet_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetId"),
field_value,
);
}
if let Some(ref field_value) = obj.vpc_endpoint_type {
params.put(&format!("{}{}", prefix, "VpcEndpointType"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcEndpointResult {
pub client_token: Option<String>,
pub vpc_endpoint: Option<VpcEndpoint>,
}
struct CreateVpcEndpointResultDeserializer;
impl CreateVpcEndpointResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpcEndpointResult, XmlParseError> {
deserialize_elements::<_, CreateVpcEndpointResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"vpcEndpoint" => {
obj.vpc_endpoint =
Some(VpcEndpointDeserializer::deserialize("vpcEndpoint", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcEndpointServiceConfigurationRequest {
pub acceptance_required: Option<bool>,
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub network_load_balancer_arns: Vec<String>,
}
struct CreateVpcEndpointServiceConfigurationRequestSerializer;
impl CreateVpcEndpointServiceConfigurationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &CreateVpcEndpointServiceConfigurationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.acceptance_required {
params.put(&format!("{}{}", prefix, "AcceptanceRequired"), &field_value);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkLoadBalancerArn"),
&obj.network_load_balancer_arns,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcEndpointServiceConfigurationResult {
pub client_token: Option<String>,
pub service_configuration: Option<ServiceConfiguration>,
}
struct CreateVpcEndpointServiceConfigurationResultDeserializer;
impl CreateVpcEndpointServiceConfigurationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpcEndpointServiceConfigurationResult, XmlParseError> {
deserialize_elements::<_, CreateVpcEndpointServiceConfigurationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"serviceConfiguration" => {
obj.service_configuration =
Some(ServiceConfigurationDeserializer::deserialize(
"serviceConfiguration",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcPeeringConnectionRequest {
pub dry_run: Option<bool>,
pub peer_owner_id: Option<String>,
pub peer_region: Option<String>,
pub peer_vpc_id: Option<String>,
pub vpc_id: Option<String>,
}
struct CreateVpcPeeringConnectionRequestSerializer;
impl CreateVpcPeeringConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVpcPeeringConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.peer_owner_id {
params.put(&format!("{}{}", prefix, "PeerOwnerId"), &field_value);
}
if let Some(ref field_value) = obj.peer_region {
params.put(&format!("{}{}", prefix, "PeerRegion"), &field_value);
}
if let Some(ref field_value) = obj.peer_vpc_id {
params.put(&format!("{}{}", prefix, "PeerVpcId"), &field_value);
}
if let Some(ref field_value) = obj.vpc_id {
params.put(&format!("{}{}", prefix, "VpcId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcPeeringConnectionResult {
pub vpc_peering_connection: Option<VpcPeeringConnection>,
}
struct CreateVpcPeeringConnectionResultDeserializer;
impl CreateVpcPeeringConnectionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpcPeeringConnectionResult, XmlParseError> {
deserialize_elements::<_, CreateVpcPeeringConnectionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpcPeeringConnection" => {
obj.vpc_peering_connection =
Some(VpcPeeringConnectionDeserializer::deserialize(
"vpcPeeringConnection",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcRequest {
pub amazon_provided_ipv_6_cidr_block: Option<bool>,
pub cidr_block: String,
pub dry_run: Option<bool>,
pub instance_tenancy: Option<String>,
}
struct CreateVpcRequestSerializer;
impl CreateVpcRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVpcRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.amazon_provided_ipv_6_cidr_block {
params.put(
&format!("{}{}", prefix, "AmazonProvidedIpv6CidrBlock"),
&field_value,
);
}
params.put(&format!("{}{}", prefix, "CidrBlock"), &obj.cidr_block);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.instance_tenancy {
params.put(&format!("{}{}", prefix, "InstanceTenancy"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpcResult {
pub vpc: Option<Vpc>,
}
struct CreateVpcResultDeserializer;
impl CreateVpcResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpcResult, XmlParseError> {
deserialize_elements::<_, CreateVpcResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"vpc" => {
obj.vpc = Some(VpcDeserializer::deserialize("vpc", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpnConnectionRequest {
pub customer_gateway_id: String,
pub dry_run: Option<bool>,
pub options: Option<VpnConnectionOptionsSpecification>,
pub transit_gateway_id: Option<String>,
pub type_: String,
pub vpn_gateway_id: Option<String>,
}
struct CreateVpnConnectionRequestSerializer;
impl CreateVpnConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVpnConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CustomerGatewayId"),
&obj.customer_gateway_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.options {
VpnConnectionOptionsSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "Options"),
field_value,
);
}
if let Some(ref field_value) = obj.transit_gateway_id {
params.put(&format!("{}{}", prefix, "TransitGatewayId"), &field_value);
}
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
if let Some(ref field_value) = obj.vpn_gateway_id {
params.put(&format!("{}{}", prefix, "VpnGatewayId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpnConnectionResult {
pub vpn_connection: Option<VpnConnection>,
}
struct CreateVpnConnectionResultDeserializer;
impl CreateVpnConnectionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpnConnectionResult, XmlParseError> {
deserialize_elements::<_, CreateVpnConnectionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpnConnection" => {
obj.vpn_connection = Some(VpnConnectionDeserializer::deserialize(
"vpnConnection",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpnConnectionRouteRequest {
pub destination_cidr_block: String,
pub vpn_connection_id: String,
}
struct CreateVpnConnectionRouteRequestSerializer;
impl CreateVpnConnectionRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVpnConnectionRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
params.put(
&format!("{}{}", prefix, "VpnConnectionId"),
&obj.vpn_connection_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpnGatewayRequest {
pub amazon_side_asn: Option<i64>,
pub availability_zone: Option<String>,
pub dry_run: Option<bool>,
pub type_: String,
}
struct CreateVpnGatewayRequestSerializer;
impl CreateVpnGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateVpnGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.amazon_side_asn {
params.put(&format!("{}{}", prefix, "AmazonSideAsn"), &field_value);
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVpnGatewayResult {
pub vpn_gateway: Option<VpnGateway>,
}
struct CreateVpnGatewayResultDeserializer;
impl CreateVpnGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVpnGatewayResult, XmlParseError> {
deserialize_elements::<_, CreateVpnGatewayResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"vpnGateway" => {
obj.vpn_gateway =
Some(VpnGatewayDeserializer::deserialize("vpnGateway", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreditSpecification {
pub cpu_credits: Option<String>,
}
struct CreditSpecificationDeserializer;
impl CreditSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreditSpecification, XmlParseError> {
deserialize_elements::<_, CreditSpecification, _>(tag_name, stack, |name, stack, obj| {
match name {
"cpuCredits" => {
obj.cpu_credits = Some(StringDeserializer::deserialize("cpuCredits", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreditSpecificationRequest {
pub cpu_credits: String,
}
struct CreditSpecificationRequestSerializer;
impl CreditSpecificationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreditSpecificationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "CpuCredits"), &obj.cpu_credits);
}
}
struct CurrencyCodeValuesDeserializer;
impl CurrencyCodeValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CustomerGateway {
pub bgp_asn: Option<String>,
pub customer_gateway_id: Option<String>,
pub ip_address: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub type_: Option<String>,
}
struct CustomerGatewayDeserializer;
impl CustomerGatewayDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomerGateway, XmlParseError> {
deserialize_elements::<_, CustomerGateway, _>(tag_name, stack, |name, stack, obj| {
match name {
"bgpAsn" => {
obj.bgp_asn = Some(StringDeserializer::deserialize("bgpAsn", stack)?);
}
"customerGatewayId" => {
obj.customer_gateway_id =
Some(StringDeserializer::deserialize("customerGatewayId", stack)?);
}
"ipAddress" => {
obj.ip_address = Some(StringDeserializer::deserialize("ipAddress", stack)?);
}
"state" => {
obj.state = Some(StringDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"type" => {
obj.type_ = Some(StringDeserializer::deserialize("type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CustomerGatewayIdStringListSerializer;
impl CustomerGatewayIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct CustomerGatewayListDeserializer;
impl CustomerGatewayListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CustomerGateway>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(CustomerGatewayDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct DatafeedSubscriptionStateDeserializer;
impl DatafeedSubscriptionStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DateTimeDeserializer;
impl DateTimeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DefaultRouteTableAssociationValueDeserializer;
impl DefaultRouteTableAssociationValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DefaultRouteTablePropagationValueDeserializer;
impl DefaultRouteTablePropagationValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DefaultTargetCapacityTypeDeserializer;
impl DefaultTargetCapacityTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteClientVpnEndpointRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
}
struct DeleteClientVpnEndpointRequestSerializer;
impl DeleteClientVpnEndpointRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClientVpnEndpointRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteClientVpnEndpointResult {
pub status: Option<ClientVpnEndpointStatus>,
}
struct DeleteClientVpnEndpointResultDeserializer;
impl DeleteClientVpnEndpointResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteClientVpnEndpointResult, XmlParseError> {
deserialize_elements::<_, DeleteClientVpnEndpointResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"status" => {
obj.status = Some(ClientVpnEndpointStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteClientVpnRouteRequest {
pub client_vpn_endpoint_id: String,
pub destination_cidr_block: String,
pub dry_run: Option<bool>,
pub target_vpc_subnet_id: Option<String>,
}
struct DeleteClientVpnRouteRequestSerializer;
impl DeleteClientVpnRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClientVpnRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.target_vpc_subnet_id {
params.put(&format!("{}{}", prefix, "TargetVpcSubnetId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteClientVpnRouteResult {
pub status: Option<ClientVpnRouteStatus>,
}
struct DeleteClientVpnRouteResultDeserializer;
impl DeleteClientVpnRouteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteClientVpnRouteResult, XmlParseError> {
deserialize_elements::<_, DeleteClientVpnRouteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"status" => {
obj.status = Some(ClientVpnRouteStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteCustomerGatewayRequest {
pub customer_gateway_id: String,
pub dry_run: Option<bool>,
}
struct DeleteCustomerGatewayRequestSerializer;
impl DeleteCustomerGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteCustomerGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CustomerGatewayId"),
&obj.customer_gateway_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDhcpOptionsRequest {
pub dhcp_options_id: String,
pub dry_run: Option<bool>,
}
struct DeleteDhcpOptionsRequestSerializer;
impl DeleteDhcpOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDhcpOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DhcpOptionsId"),
&obj.dhcp_options_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteEgressOnlyInternetGatewayRequest {
pub dry_run: Option<bool>,
pub egress_only_internet_gateway_id: String,
}
struct DeleteEgressOnlyInternetGatewayRequestSerializer;
impl DeleteEgressOnlyInternetGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteEgressOnlyInternetGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "EgressOnlyInternetGatewayId"),
&obj.egress_only_internet_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteEgressOnlyInternetGatewayResult {
pub return_code: Option<bool>,
}
struct DeleteEgressOnlyInternetGatewayResultDeserializer;
impl DeleteEgressOnlyInternetGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteEgressOnlyInternetGatewayResult, XmlParseError> {
deserialize_elements::<_, DeleteEgressOnlyInternetGatewayResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"returnCode" => {
obj.return_code =
Some(BooleanDeserializer::deserialize("returnCode", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFleetError {
pub code: Option<String>,
pub message: Option<String>,
}
struct DeleteFleetErrorDeserializer;
impl DeleteFleetErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteFleetError, XmlParseError> {
deserialize_elements::<_, DeleteFleetError, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(DeleteFleetErrorCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DeleteFleetErrorCodeDeserializer;
impl DeleteFleetErrorCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFleetErrorItem {
pub error: Option<DeleteFleetError>,
pub fleet_id: Option<String>,
}
struct DeleteFleetErrorItemDeserializer;
impl DeleteFleetErrorItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteFleetErrorItem, XmlParseError> {
deserialize_elements::<_, DeleteFleetErrorItem, _>(tag_name, stack, |name, stack, obj| {
match name {
"error" => {
obj.error = Some(DeleteFleetErrorDeserializer::deserialize("error", stack)?);
}
"fleetId" => {
obj.fleet_id =
Some(FleetIdentifierDeserializer::deserialize("fleetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DeleteFleetErrorSetDeserializer;
impl DeleteFleetErrorSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DeleteFleetErrorItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DeleteFleetErrorItemDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFleetSuccessItem {
pub current_fleet_state: Option<String>,
pub fleet_id: Option<String>,
pub previous_fleet_state: Option<String>,
}
struct DeleteFleetSuccessItemDeserializer;
impl DeleteFleetSuccessItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteFleetSuccessItem, XmlParseError> {
deserialize_elements::<_, DeleteFleetSuccessItem, _>(tag_name, stack, |name, stack, obj| {
match name {
"currentFleetState" => {
obj.current_fleet_state = Some(FleetStateCodeDeserializer::deserialize(
"currentFleetState",
stack,
)?);
}
"fleetId" => {
obj.fleet_id =
Some(FleetIdentifierDeserializer::deserialize("fleetId", stack)?);
}
"previousFleetState" => {
obj.previous_fleet_state = Some(FleetStateCodeDeserializer::deserialize(
"previousFleetState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DeleteFleetSuccessSetDeserializer;
impl DeleteFleetSuccessSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DeleteFleetSuccessItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DeleteFleetSuccessItemDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFleetsRequest {
pub dry_run: Option<bool>,
pub fleet_ids: Vec<String>,
pub terminate_instances: bool,
}
struct DeleteFleetsRequestSerializer;
impl DeleteFleetsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteFleetsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
FleetIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "FleetId"),
&obj.fleet_ids,
);
params.put(
&format!("{}{}", prefix, "TerminateInstances"),
&obj.terminate_instances,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFleetsResult {
pub successful_fleet_deletions: Option<Vec<DeleteFleetSuccessItem>>,
pub unsuccessful_fleet_deletions: Option<Vec<DeleteFleetErrorItem>>,
}
struct DeleteFleetsResultDeserializer;
impl DeleteFleetsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteFleetsResult, XmlParseError> {
deserialize_elements::<_, DeleteFleetsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"successfulFleetDeletionSet" => {
obj.successful_fleet_deletions.get_or_insert(vec![]).extend(
DeleteFleetSuccessSetDeserializer::deserialize(
"successfulFleetDeletionSet",
stack,
)?,
);
}
"unsuccessfulFleetDeletionSet" => {
obj.unsuccessful_fleet_deletions
.get_or_insert(vec![])
.extend(DeleteFleetErrorSetDeserializer::deserialize(
"unsuccessfulFleetDeletionSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFlowLogsRequest {
pub dry_run: Option<bool>,
pub flow_log_ids: Vec<String>,
}
struct DeleteFlowLogsRequestSerializer;
impl DeleteFlowLogsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteFlowLogsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "FlowLogId"),
&obj.flow_log_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFlowLogsResult {
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct DeleteFlowLogsResultDeserializer;
impl DeleteFlowLogsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteFlowLogsResult, XmlParseError> {
deserialize_elements::<_, DeleteFlowLogsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFpgaImageRequest {
pub dry_run: Option<bool>,
pub fpga_image_id: String,
}
struct DeleteFpgaImageRequestSerializer;
impl DeleteFpgaImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteFpgaImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "FpgaImageId"), &obj.fpga_image_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteFpgaImageResult {
pub return_: Option<bool>,
}
struct DeleteFpgaImageResultDeserializer;
impl DeleteFpgaImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteFpgaImageResult, XmlParseError> {
deserialize_elements::<_, DeleteFpgaImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteInternetGatewayRequest {
pub dry_run: Option<bool>,
pub internet_gateway_id: String,
}
struct DeleteInternetGatewayRequestSerializer;
impl DeleteInternetGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteInternetGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InternetGatewayId"),
&obj.internet_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteKeyPairRequest {
pub dry_run: Option<bool>,
pub key_name: String,
}
struct DeleteKeyPairRequestSerializer;
impl DeleteKeyPairRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteKeyPairRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "KeyName"), &obj.key_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLaunchTemplateRequest {
pub dry_run: Option<bool>,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
}
struct DeleteLaunchTemplateRequestSerializer;
impl DeleteLaunchTemplateRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteLaunchTemplateRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLaunchTemplateResult {
pub launch_template: Option<LaunchTemplate>,
}
struct DeleteLaunchTemplateResultDeserializer;
impl DeleteLaunchTemplateResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteLaunchTemplateResult, XmlParseError> {
deserialize_elements::<_, DeleteLaunchTemplateResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplate" => {
obj.launch_template = Some(LaunchTemplateDeserializer::deserialize(
"launchTemplate",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLaunchTemplateVersionsRequest {
pub dry_run: Option<bool>,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub versions: Vec<String>,
}
struct DeleteLaunchTemplateVersionsRequestSerializer;
impl DeleteLaunchTemplateVersionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteLaunchTemplateVersionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
VersionStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateVersion"),
&obj.versions,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLaunchTemplateVersionsResponseErrorItem {
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub response_error: Option<ResponseError>,
pub version_number: Option<i64>,
}
struct DeleteLaunchTemplateVersionsResponseErrorItemDeserializer;
impl DeleteLaunchTemplateVersionsResponseErrorItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteLaunchTemplateVersionsResponseErrorItem, XmlParseError> {
deserialize_elements::<_, DeleteLaunchTemplateVersionsResponseErrorItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateId" => {
obj.launch_template_id =
Some(StringDeserializer::deserialize("launchTemplateId", stack)?);
}
"launchTemplateName" => {
obj.launch_template_name = Some(StringDeserializer::deserialize(
"launchTemplateName",
stack,
)?);
}
"responseError" => {
obj.response_error = Some(ResponseErrorDeserializer::deserialize(
"responseError",
stack,
)?);
}
"versionNumber" => {
obj.version_number =
Some(LongDeserializer::deserialize("versionNumber", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct DeleteLaunchTemplateVersionsResponseErrorSetDeserializer;
impl DeleteLaunchTemplateVersionsResponseErrorSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DeleteLaunchTemplateVersionsResponseErrorItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
DeleteLaunchTemplateVersionsResponseErrorItemDeserializer::deserialize(
"item", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLaunchTemplateVersionsResponseSuccessItem {
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub version_number: Option<i64>,
}
struct DeleteLaunchTemplateVersionsResponseSuccessItemDeserializer;
impl DeleteLaunchTemplateVersionsResponseSuccessItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteLaunchTemplateVersionsResponseSuccessItem, XmlParseError> {
deserialize_elements::<_, DeleteLaunchTemplateVersionsResponseSuccessItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateId" => {
obj.launch_template_id =
Some(StringDeserializer::deserialize("launchTemplateId", stack)?);
}
"launchTemplateName" => {
obj.launch_template_name = Some(StringDeserializer::deserialize(
"launchTemplateName",
stack,
)?);
}
"versionNumber" => {
obj.version_number =
Some(LongDeserializer::deserialize("versionNumber", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct DeleteLaunchTemplateVersionsResponseSuccessSetDeserializer;
impl DeleteLaunchTemplateVersionsResponseSuccessSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DeleteLaunchTemplateVersionsResponseSuccessItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
DeleteLaunchTemplateVersionsResponseSuccessItemDeserializer::deserialize(
"item", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLaunchTemplateVersionsResult {
pub successfully_deleted_launch_template_versions:
Option<Vec<DeleteLaunchTemplateVersionsResponseSuccessItem>>,
pub unsuccessfully_deleted_launch_template_versions:
Option<Vec<DeleteLaunchTemplateVersionsResponseErrorItem>>,
}
struct DeleteLaunchTemplateVersionsResultDeserializer;
impl DeleteLaunchTemplateVersionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteLaunchTemplateVersionsResult, XmlParseError> {
deserialize_elements::<_, DeleteLaunchTemplateVersionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"successfullyDeletedLaunchTemplateVersionSet" => {
obj.successfully_deleted_launch_template_versions
.get_or_insert(vec![])
.extend(DeleteLaunchTemplateVersionsResponseSuccessSetDeserializer::deserialize("successfullyDeletedLaunchTemplateVersionSet", stack)?);
}
"unsuccessfullyDeletedLaunchTemplateVersionSet" => {
obj.unsuccessfully_deleted_launch_template_versions
.get_or_insert(vec![])
.extend(DeleteLaunchTemplateVersionsResponseErrorSetDeserializer::deserialize("unsuccessfullyDeletedLaunchTemplateVersionSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNatGatewayRequest {
pub nat_gateway_id: String,
}
struct DeleteNatGatewayRequestSerializer;
impl DeleteNatGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteNatGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "NatGatewayId"),
&obj.nat_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNatGatewayResult {
pub nat_gateway_id: Option<String>,
}
struct DeleteNatGatewayResultDeserializer;
impl DeleteNatGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteNatGatewayResult, XmlParseError> {
deserialize_elements::<_, DeleteNatGatewayResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"natGatewayId" => {
obj.nat_gateway_id =
Some(StringDeserializer::deserialize("natGatewayId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNetworkAclEntryRequest {
pub dry_run: Option<bool>,
pub egress: bool,
pub network_acl_id: String,
pub rule_number: i64,
}
struct DeleteNetworkAclEntryRequestSerializer;
impl DeleteNetworkAclEntryRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteNetworkAclEntryRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "Egress"), &obj.egress);
params.put(
&format!("{}{}", prefix, "NetworkAclId"),
&obj.network_acl_id,
);
params.put(&format!("{}{}", prefix, "RuleNumber"), &obj.rule_number);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNetworkAclRequest {
pub dry_run: Option<bool>,
pub network_acl_id: String,
}
struct DeleteNetworkAclRequestSerializer;
impl DeleteNetworkAclRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteNetworkAclRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkAclId"),
&obj.network_acl_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNetworkInterfacePermissionRequest {
pub dry_run: Option<bool>,
pub force: Option<bool>,
pub network_interface_permission_id: String,
}
struct DeleteNetworkInterfacePermissionRequestSerializer;
impl DeleteNetworkInterfacePermissionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteNetworkInterfacePermissionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfacePermissionId"),
&obj.network_interface_permission_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNetworkInterfacePermissionResult {
pub return_: Option<bool>,
}
struct DeleteNetworkInterfacePermissionResultDeserializer;
impl DeleteNetworkInterfacePermissionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteNetworkInterfacePermissionResult, XmlParseError> {
deserialize_elements::<_, DeleteNetworkInterfacePermissionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNetworkInterfaceRequest {
pub dry_run: Option<bool>,
pub network_interface_id: String,
}
struct DeleteNetworkInterfaceRequestSerializer;
impl DeleteNetworkInterfaceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteNetworkInterfaceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeletePlacementGroupRequest {
pub dry_run: Option<bool>,
pub group_name: String,
}
struct DeletePlacementGroupRequestSerializer;
impl DeletePlacementGroupRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeletePlacementGroupRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "GroupName"), &obj.group_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteRouteRequest {
pub destination_cidr_block: Option<String>,
pub destination_ipv_6_cidr_block: Option<String>,
pub dry_run: Option<bool>,
pub route_table_id: String,
}
struct DeleteRouteRequestSerializer;
impl DeleteRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.destination_cidr_block {
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.destination_ipv_6_cidr_block {
params.put(
&format!("{}{}", prefix, "DestinationIpv6CidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteRouteTableRequest {
pub dry_run: Option<bool>,
pub route_table_id: String,
}
struct DeleteRouteTableRequestSerializer;
impl DeleteRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteSecurityGroupRequest {
pub dry_run: Option<bool>,
pub group_id: Option<String>,
pub group_name: Option<String>,
}
struct DeleteSecurityGroupRequestSerializer;
impl DeleteSecurityGroupRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSecurityGroupRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteSnapshotRequest {
pub dry_run: Option<bool>,
pub snapshot_id: String,
}
struct DeleteSnapshotRequestSerializer;
impl DeleteSnapshotRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSnapshotRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "SnapshotId"), &obj.snapshot_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteSpotDatafeedSubscriptionRequest {
pub dry_run: Option<bool>,
}
struct DeleteSpotDatafeedSubscriptionRequestSerializer;
impl DeleteSpotDatafeedSubscriptionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSpotDatafeedSubscriptionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteSubnetRequest {
pub dry_run: Option<bool>,
pub subnet_id: String,
}
struct DeleteSubnetRequestSerializer;
impl DeleteSubnetRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSubnetRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTagsRequest {
pub dry_run: Option<bool>,
pub resources: Vec<String>,
pub tags: Option<Vec<Tag>>,
}
struct DeleteTagsRequestSerializer;
impl DeleteTagsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTagsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ResourceIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceId"),
&obj.resources,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayRequest {
pub dry_run: Option<bool>,
pub transit_gateway_id: String,
}
struct DeleteTransitGatewayRequestSerializer;
impl DeleteTransitGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTransitGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayId"),
&obj.transit_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayResult {
pub transit_gateway: Option<TransitGateway>,
}
struct DeleteTransitGatewayResultDeserializer;
impl DeleteTransitGatewayResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteTransitGatewayResult, XmlParseError> {
deserialize_elements::<_, DeleteTransitGatewayResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGateway" => {
obj.transit_gateway = Some(TransitGatewayDeserializer::deserialize(
"transitGateway",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayRouteRequest {
pub destination_cidr_block: String,
pub dry_run: Option<bool>,
pub transit_gateway_route_table_id: String,
}
struct DeleteTransitGatewayRouteRequestSerializer;
impl DeleteTransitGatewayRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTransitGatewayRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayRouteResult {
pub route: Option<TransitGatewayRoute>,
}
struct DeleteTransitGatewayRouteResultDeserializer;
impl DeleteTransitGatewayRouteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteTransitGatewayRouteResult, XmlParseError> {
deserialize_elements::<_, DeleteTransitGatewayRouteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"route" => {
obj.route = Some(TransitGatewayRouteDeserializer::deserialize(
"route", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayRouteTableRequest {
pub dry_run: Option<bool>,
pub transit_gateway_route_table_id: String,
}
struct DeleteTransitGatewayRouteTableRequestSerializer;
impl DeleteTransitGatewayRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTransitGatewayRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayRouteTableResult {
pub transit_gateway_route_table: Option<TransitGatewayRouteTable>,
}
struct DeleteTransitGatewayRouteTableResultDeserializer;
impl DeleteTransitGatewayRouteTableResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteTransitGatewayRouteTableResult, XmlParseError> {
deserialize_elements::<_, DeleteTransitGatewayRouteTableResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayRouteTable" => {
obj.transit_gateway_route_table =
Some(TransitGatewayRouteTableDeserializer::deserialize(
"transitGatewayRouteTable",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayVpcAttachmentRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
}
struct DeleteTransitGatewayVpcAttachmentRequestSerializer;
impl DeleteTransitGatewayVpcAttachmentRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTransitGatewayVpcAttachmentRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTransitGatewayVpcAttachmentResult {
pub transit_gateway_vpc_attachment: Option<TransitGatewayVpcAttachment>,
}
struct DeleteTransitGatewayVpcAttachmentResultDeserializer;
impl DeleteTransitGatewayVpcAttachmentResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteTransitGatewayVpcAttachmentResult, XmlParseError> {
deserialize_elements::<_, DeleteTransitGatewayVpcAttachmentResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayVpcAttachment" => {
obj.transit_gateway_vpc_attachment =
Some(TransitGatewayVpcAttachmentDeserializer::deserialize(
"transitGatewayVpcAttachment",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVolumeRequest {
pub dry_run: Option<bool>,
pub volume_id: String,
}
struct DeleteVolumeRequestSerializer;
impl DeleteVolumeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVolumeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcEndpointConnectionNotificationsRequest {
pub connection_notification_ids: Vec<String>,
pub dry_run: Option<bool>,
}
struct DeleteVpcEndpointConnectionNotificationsRequestSerializer;
impl DeleteVpcEndpointConnectionNotificationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DeleteVpcEndpointConnectionNotificationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ConnectionNotificationId"),
&obj.connection_notification_ids,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcEndpointConnectionNotificationsResult {
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct DeleteVpcEndpointConnectionNotificationsResultDeserializer;
impl DeleteVpcEndpointConnectionNotificationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteVpcEndpointConnectionNotificationsResult, XmlParseError> {
deserialize_elements::<_, DeleteVpcEndpointConnectionNotificationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcEndpointServiceConfigurationsRequest {
pub dry_run: Option<bool>,
pub service_ids: Vec<String>,
}
struct DeleteVpcEndpointServiceConfigurationsRequestSerializer;
impl DeleteVpcEndpointServiceConfigurationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DeleteVpcEndpointServiceConfigurationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ServiceId"),
&obj.service_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcEndpointServiceConfigurationsResult {
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct DeleteVpcEndpointServiceConfigurationsResultDeserializer;
impl DeleteVpcEndpointServiceConfigurationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteVpcEndpointServiceConfigurationsResult, XmlParseError> {
deserialize_elements::<_, DeleteVpcEndpointServiceConfigurationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcEndpointsRequest {
pub dry_run: Option<bool>,
pub vpc_endpoint_ids: Vec<String>,
}
struct DeleteVpcEndpointsRequestSerializer;
impl DeleteVpcEndpointsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVpcEndpointsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcEndpointId"),
&obj.vpc_endpoint_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcEndpointsResult {
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct DeleteVpcEndpointsResultDeserializer;
impl DeleteVpcEndpointsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteVpcEndpointsResult, XmlParseError> {
deserialize_elements::<_, DeleteVpcEndpointsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcPeeringConnectionRequest {
pub dry_run: Option<bool>,
pub vpc_peering_connection_id: String,
}
struct DeleteVpcPeeringConnectionRequestSerializer;
impl DeleteVpcPeeringConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVpcPeeringConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&obj.vpc_peering_connection_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcPeeringConnectionResult {
pub return_: Option<bool>,
}
struct DeleteVpcPeeringConnectionResultDeserializer;
impl DeleteVpcPeeringConnectionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteVpcPeeringConnectionResult, XmlParseError> {
deserialize_elements::<_, DeleteVpcPeeringConnectionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpcRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct DeleteVpcRequestSerializer;
impl DeleteVpcRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVpcRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpnConnectionRequest {
pub dry_run: Option<bool>,
pub vpn_connection_id: String,
}
struct DeleteVpnConnectionRequestSerializer;
impl DeleteVpnConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVpnConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "VpnConnectionId"),
&obj.vpn_connection_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpnConnectionRouteRequest {
pub destination_cidr_block: String,
pub vpn_connection_id: String,
}
struct DeleteVpnConnectionRouteRequestSerializer;
impl DeleteVpnConnectionRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVpnConnectionRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
params.put(
&format!("{}{}", prefix, "VpnConnectionId"),
&obj.vpn_connection_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVpnGatewayRequest {
pub dry_run: Option<bool>,
pub vpn_gateway_id: String,
}
struct DeleteVpnGatewayRequestSerializer;
impl DeleteVpnGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteVpnGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "VpnGatewayId"),
&obj.vpn_gateway_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeprovisionByoipCidrRequest {
pub cidr: String,
pub dry_run: Option<bool>,
}
struct DeprovisionByoipCidrRequestSerializer;
impl DeprovisionByoipCidrRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeprovisionByoipCidrRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Cidr"), &obj.cidr);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeprovisionByoipCidrResult {
pub byoip_cidr: Option<ByoipCidr>,
}
struct DeprovisionByoipCidrResultDeserializer;
impl DeprovisionByoipCidrResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeprovisionByoipCidrResult, XmlParseError> {
deserialize_elements::<_, DeprovisionByoipCidrResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"byoipCidr" => {
obj.byoip_cidr =
Some(ByoipCidrDeserializer::deserialize("byoipCidr", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeregisterImageRequest {
pub dry_run: Option<bool>,
pub image_id: String,
}
struct DeregisterImageRequestSerializer;
impl DeregisterImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeregisterImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "ImageId"), &obj.image_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAccountAttributesRequest {
pub attribute_names: Option<Vec<String>>,
pub dry_run: Option<bool>,
}
struct DescribeAccountAttributesRequestSerializer;
impl DescribeAccountAttributesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAccountAttributesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute_names {
AccountAttributeNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AttributeName"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAccountAttributesResult {
pub account_attributes: Option<Vec<AccountAttribute>>,
}
struct DescribeAccountAttributesResultDeserializer;
impl DescribeAccountAttributesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAccountAttributesResult, XmlParseError> {
deserialize_elements::<_, DescribeAccountAttributesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"accountAttributeSet" => {
obj.account_attributes.get_or_insert(vec![]).extend(
AccountAttributeListDeserializer::deserialize(
"accountAttributeSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAddressesRequest {
pub allocation_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub public_ips: Option<Vec<String>>,
}
struct DescribeAddressesRequestSerializer;
impl DescribeAddressesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAddressesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocation_ids {
AllocationIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "AllocationId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.public_ips {
PublicIpStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "PublicIp"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAddressesResult {
pub addresses: Option<Vec<Address>>,
}
struct DescribeAddressesResultDeserializer;
impl DescribeAddressesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAddressesResult, XmlParseError> {
deserialize_elements::<_, DescribeAddressesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"addressesSet" => {
obj.addresses
.get_or_insert(vec![])
.extend(AddressListDeserializer::deserialize("addressesSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAggregateIdFormatRequest {
pub dry_run: Option<bool>,
}
struct DescribeAggregateIdFormatRequestSerializer;
impl DescribeAggregateIdFormatRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAggregateIdFormatRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAggregateIdFormatResult {
pub statuses: Option<Vec<IdFormat>>,
pub use_long_ids_aggregated: Option<bool>,
}
struct DescribeAggregateIdFormatResultDeserializer;
impl DescribeAggregateIdFormatResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAggregateIdFormatResult, XmlParseError> {
deserialize_elements::<_, DescribeAggregateIdFormatResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"statusSet" => {
obj.statuses
.get_or_insert(vec![])
.extend(IdFormatListDeserializer::deserialize("statusSet", stack)?);
}
"useLongIdsAggregated" => {
obj.use_long_ids_aggregated = Some(BooleanDeserializer::deserialize(
"useLongIdsAggregated",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAvailabilityZonesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub zone_ids: Option<Vec<String>>,
pub zone_names: Option<Vec<String>>,
}
struct DescribeAvailabilityZonesRequestSerializer;
impl DescribeAvailabilityZonesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAvailabilityZonesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.zone_ids {
ZoneIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ZoneId"),
field_value,
);
}
if let Some(ref field_value) = obj.zone_names {
ZoneNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ZoneName"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAvailabilityZonesResult {
pub availability_zones: Option<Vec<AvailabilityZone>>,
}
struct DescribeAvailabilityZonesResultDeserializer;
impl DescribeAvailabilityZonesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAvailabilityZonesResult, XmlParseError> {
deserialize_elements::<_, DescribeAvailabilityZonesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZoneInfo" => {
obj.availability_zones.get_or_insert(vec![]).extend(
AvailabilityZoneListDeserializer::deserialize(
"availabilityZoneInfo",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeBundleTasksRequest {
pub bundle_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
}
struct DescribeBundleTasksRequestSerializer;
impl DescribeBundleTasksRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeBundleTasksRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.bundle_ids {
BundleIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "BundleId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeBundleTasksResult {
pub bundle_tasks: Option<Vec<BundleTask>>,
}
struct DescribeBundleTasksResultDeserializer;
impl DescribeBundleTasksResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeBundleTasksResult, XmlParseError> {
deserialize_elements::<_, DescribeBundleTasksResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"bundleInstanceTasksSet" => {
obj.bundle_tasks.get_or_insert(vec![]).extend(
BundleTaskListDeserializer::deserialize(
"bundleInstanceTasksSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeByoipCidrsRequest {
pub dry_run: Option<bool>,
pub max_results: i64,
pub next_token: Option<String>,
}
struct DescribeByoipCidrsRequestSerializer;
impl DescribeByoipCidrsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeByoipCidrsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "MaxResults"), &obj.max_results);
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeByoipCidrsResult {
pub byoip_cidrs: Option<Vec<ByoipCidr>>,
pub next_token: Option<String>,
}
struct DescribeByoipCidrsResultDeserializer;
impl DescribeByoipCidrsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeByoipCidrsResult, XmlParseError> {
deserialize_elements::<_, DescribeByoipCidrsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"byoipCidrSet" => {
obj.byoip_cidrs.get_or_insert(vec![]).extend(
ByoipCidrSetDeserializer::deserialize("byoipCidrSet", stack)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeCapacityReservationsRequest {
pub capacity_reservation_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeCapacityReservationsRequestSerializer;
impl DescribeCapacityReservationsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCapacityReservationsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capacity_reservation_ids {
CapacityReservationIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "CapacityReservationId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeCapacityReservationsResult {
pub capacity_reservations: Option<Vec<CapacityReservation>>,
pub next_token: Option<String>,
}
struct DescribeCapacityReservationsResultDeserializer;
impl DescribeCapacityReservationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeCapacityReservationsResult, XmlParseError> {
deserialize_elements::<_, DescribeCapacityReservationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"capacityReservationSet" => {
obj.capacity_reservations.get_or_insert(vec![]).extend(
CapacityReservationSetDeserializer::deserialize(
"capacityReservationSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClassicLinkInstancesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub instance_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeClassicLinkInstancesRequestSerializer;
impl DescribeClassicLinkInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClassicLinkInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_ids {
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClassicLinkInstancesResult {
pub instances: Option<Vec<ClassicLinkInstance>>,
pub next_token: Option<String>,
}
struct DescribeClassicLinkInstancesResultDeserializer;
impl DescribeClassicLinkInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeClassicLinkInstancesResult, XmlParseError> {
deserialize_elements::<_, DescribeClassicLinkInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instancesSet" => {
obj.instances.get_or_insert(vec![]).extend(
ClassicLinkInstanceListDeserializer::deserialize(
"instancesSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnAuthorizationRulesRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeClientVpnAuthorizationRulesRequestSerializer;
impl DescribeClientVpnAuthorizationRulesRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeClientVpnAuthorizationRulesRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnAuthorizationRulesResult {
pub authorization_rules: Option<Vec<AuthorizationRule>>,
pub next_token: Option<String>,
}
struct DescribeClientVpnAuthorizationRulesResultDeserializer;
impl DescribeClientVpnAuthorizationRulesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeClientVpnAuthorizationRulesResult, XmlParseError> {
deserialize_elements::<_, DescribeClientVpnAuthorizationRulesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"authorizationRule" => {
obj.authorization_rules.get_or_insert(vec![]).extend(
AuthorizationRuleSetDeserializer::deserialize(
"authorizationRule",
stack,
)?,
);
}
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnConnectionsRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeClientVpnConnectionsRequestSerializer;
impl DescribeClientVpnConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClientVpnConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnConnectionsResult {
pub connections: Option<Vec<ClientVpnConnection>>,
pub next_token: Option<String>,
}
struct DescribeClientVpnConnectionsResultDeserializer;
impl DescribeClientVpnConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeClientVpnConnectionsResult, XmlParseError> {
deserialize_elements::<_, DescribeClientVpnConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"connections" => {
obj.connections.get_or_insert(vec![]).extend(
ClientVpnConnectionSetDeserializer::deserialize("connections", stack)?,
);
}
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnEndpointsRequest {
pub client_vpn_endpoint_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeClientVpnEndpointsRequestSerializer;
impl DescribeClientVpnEndpointsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClientVpnEndpointsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_vpn_endpoint_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ClientVpnEndpointId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnEndpointsResult {
pub client_vpn_endpoints: Option<Vec<ClientVpnEndpoint>>,
pub next_token: Option<String>,
}
struct DescribeClientVpnEndpointsResultDeserializer;
impl DescribeClientVpnEndpointsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeClientVpnEndpointsResult, XmlParseError> {
deserialize_elements::<_, DescribeClientVpnEndpointsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientVpnEndpoint" => {
obj.client_vpn_endpoints.get_or_insert(vec![]).extend(
EndpointSetDeserializer::deserialize("clientVpnEndpoint", stack)?,
);
}
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnRoutesRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeClientVpnRoutesRequestSerializer;
impl DescribeClientVpnRoutesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClientVpnRoutesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnRoutesResult {
pub next_token: Option<String>,
pub routes: Option<Vec<ClientVpnRoute>>,
}
struct DescribeClientVpnRoutesResultDeserializer;
impl DescribeClientVpnRoutesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeClientVpnRoutesResult, XmlParseError> {
deserialize_elements::<_, DescribeClientVpnRoutesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
"routes" => {
obj.routes
.get_or_insert(vec![])
.extend(ClientVpnRouteSetDeserializer::deserialize("routes", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnTargetNetworksRequest {
pub association_ids: Option<Vec<String>>,
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeClientVpnTargetNetworksRequestSerializer;
impl DescribeClientVpnTargetNetworksRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClientVpnTargetNetworksRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.association_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AssociationIds"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeClientVpnTargetNetworksResult {
pub client_vpn_target_networks: Option<Vec<TargetNetwork>>,
pub next_token: Option<String>,
}
struct DescribeClientVpnTargetNetworksResultDeserializer;
impl DescribeClientVpnTargetNetworksResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeClientVpnTargetNetworksResult, XmlParseError> {
deserialize_elements::<_, DescribeClientVpnTargetNetworksResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientVpnTargetNetworks" => {
obj.client_vpn_target_networks.get_or_insert(vec![]).extend(
TargetNetworkSetDeserializer::deserialize(
"clientVpnTargetNetworks",
stack,
)?,
);
}
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct DescribeConversionTaskListDeserializer;
impl DescribeConversionTaskListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ConversionTask>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ConversionTaskDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeConversionTasksRequest {
pub conversion_task_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
}
struct DescribeConversionTasksRequestSerializer;
impl DescribeConversionTasksRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeConversionTasksRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.conversion_task_ids {
ConversionIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ConversionTaskId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeConversionTasksResult {
pub conversion_tasks: Option<Vec<ConversionTask>>,
}
struct DescribeConversionTasksResultDeserializer;
impl DescribeConversionTasksResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeConversionTasksResult, XmlParseError> {
deserialize_elements::<_, DescribeConversionTasksResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"conversionTasks" => {
obj.conversion_tasks.get_or_insert(vec![]).extend(
DescribeConversionTaskListDeserializer::deserialize(
"conversionTasks",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeCustomerGatewaysRequest {
pub customer_gateway_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
}
struct DescribeCustomerGatewaysRequestSerializer;
impl DescribeCustomerGatewaysRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCustomerGatewaysRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.customer_gateway_ids {
CustomerGatewayIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "CustomerGatewayId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeCustomerGatewaysResult {
pub customer_gateways: Option<Vec<CustomerGateway>>,
}
struct DescribeCustomerGatewaysResultDeserializer;
impl DescribeCustomerGatewaysResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeCustomerGatewaysResult, XmlParseError> {
deserialize_elements::<_, DescribeCustomerGatewaysResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"customerGatewaySet" => {
obj.customer_gateways.get_or_insert(vec![]).extend(
CustomerGatewayListDeserializer::deserialize(
"customerGatewaySet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDhcpOptionsRequest {
pub dhcp_options_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeDhcpOptionsRequestSerializer;
impl DescribeDhcpOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDhcpOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dhcp_options_ids {
DhcpOptionsIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "DhcpOptionsId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDhcpOptionsResult {
pub dhcp_options: Option<Vec<DhcpOptions>>,
pub next_token: Option<String>,
}
struct DescribeDhcpOptionsResultDeserializer;
impl DescribeDhcpOptionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDhcpOptionsResult, XmlParseError> {
deserialize_elements::<_, DescribeDhcpOptionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"dhcpOptionsSet" => {
obj.dhcp_options.get_or_insert(vec![]).extend(
DhcpOptionsListDeserializer::deserialize("dhcpOptionsSet", stack)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeEgressOnlyInternetGatewaysRequest {
pub dry_run: Option<bool>,
pub egress_only_internet_gateway_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeEgressOnlyInternetGatewaysRequestSerializer;
impl DescribeEgressOnlyInternetGatewaysRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeEgressOnlyInternetGatewaysRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.egress_only_internet_gateway_ids {
EgressOnlyInternetGatewayIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "EgressOnlyInternetGatewayId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeEgressOnlyInternetGatewaysResult {
pub egress_only_internet_gateways: Option<Vec<EgressOnlyInternetGateway>>,
pub next_token: Option<String>,
}
struct DescribeEgressOnlyInternetGatewaysResultDeserializer;
impl DescribeEgressOnlyInternetGatewaysResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeEgressOnlyInternetGatewaysResult, XmlParseError> {
deserialize_elements::<_, DescribeEgressOnlyInternetGatewaysResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"egressOnlyInternetGatewaySet" => {
obj.egress_only_internet_gateways
.get_or_insert(vec![])
.extend(EgressOnlyInternetGatewayListDeserializer::deserialize(
"egressOnlyInternetGatewaySet",
stack,
)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeElasticGpusRequest {
pub dry_run: Option<bool>,
pub elastic_gpu_ids: Option<Vec<String>>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeElasticGpusRequestSerializer;
impl DescribeElasticGpusRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeElasticGpusRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.elastic_gpu_ids {
ElasticGpuIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "ElasticGpuId"),
field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeElasticGpusResult {
pub elastic_gpu_set: Option<Vec<ElasticGpus>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeElasticGpusResultDeserializer;
impl DescribeElasticGpusResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeElasticGpusResult, XmlParseError> {
deserialize_elements::<_, DescribeElasticGpusResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"elasticGpuSet" => {
obj.elastic_gpu_set.get_or_insert(vec![]).extend(
ElasticGpuSetDeserializer::deserialize("elasticGpuSet", stack)?,
);
}
"maxResults" => {
obj.max_results =
Some(IntegerDeserializer::deserialize("maxResults", stack)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeExportTasksRequest {
pub export_task_ids: Option<Vec<String>>,
}
struct DescribeExportTasksRequestSerializer;
impl DescribeExportTasksRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeExportTasksRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.export_task_ids {
ExportTaskIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ExportTaskId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeExportTasksResult {
pub export_tasks: Option<Vec<ExportTask>>,
}
struct DescribeExportTasksResultDeserializer;
impl DescribeExportTasksResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeExportTasksResult, XmlParseError> {
deserialize_elements::<_, DescribeExportTasksResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"exportTaskSet" => {
obj.export_tasks.get_or_insert(vec![]).extend(
ExportTaskListDeserializer::deserialize("exportTaskSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetError {
pub error_code: Option<String>,
pub error_message: Option<String>,
pub launch_template_and_overrides: Option<LaunchTemplateAndOverridesResponse>,
pub lifecycle: Option<String>,
}
struct DescribeFleetErrorDeserializer;
impl DescribeFleetErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFleetError, XmlParseError> {
deserialize_elements::<_, DescribeFleetError, _>(tag_name, stack, |name, stack, obj| {
match name {
"errorCode" => {
obj.error_code = Some(StringDeserializer::deserialize("errorCode", stack)?);
}
"errorMessage" => {
obj.error_message =
Some(StringDeserializer::deserialize("errorMessage", stack)?);
}
"launchTemplateAndOverrides" => {
obj.launch_template_and_overrides =
Some(LaunchTemplateAndOverridesResponseDeserializer::deserialize(
"launchTemplateAndOverrides",
stack,
)?);
}
"lifecycle" => {
obj.lifecycle = Some(InstanceLifecycleDeserializer::deserialize(
"lifecycle",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetHistoryRequest {
pub dry_run: Option<bool>,
pub event_type: Option<String>,
pub fleet_id: String,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub start_time: String,
}
struct DescribeFleetHistoryRequestSerializer;
impl DescribeFleetHistoryRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeFleetHistoryRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.event_type {
params.put(&format!("{}{}", prefix, "EventType"), &field_value);
}
params.put(&format!("{}{}", prefix, "FleetId"), &obj.fleet_id);
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "StartTime"), &obj.start_time);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetHistoryResult {
pub fleet_id: Option<String>,
pub history_records: Option<Vec<HistoryRecordEntry>>,
pub last_evaluated_time: Option<String>,
pub next_token: Option<String>,
pub start_time: Option<String>,
}
struct DescribeFleetHistoryResultDeserializer;
impl DescribeFleetHistoryResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFleetHistoryResult, XmlParseError> {
deserialize_elements::<_, DescribeFleetHistoryResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"fleetId" => {
obj.fleet_id =
Some(FleetIdentifierDeserializer::deserialize("fleetId", stack)?);
}
"historyRecordSet" => {
obj.history_records.get_or_insert(vec![]).extend(
HistoryRecordSetDeserializer::deserialize("historyRecordSet", stack)?,
);
}
"lastEvaluatedTime" => {
obj.last_evaluated_time = Some(DateTimeDeserializer::deserialize(
"lastEvaluatedTime",
stack,
)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"startTime" => {
obj.start_time =
Some(DateTimeDeserializer::deserialize("startTime", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetInstancesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub fleet_id: String,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeFleetInstancesRequestSerializer;
impl DescribeFleetInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeFleetInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "FleetId"), &obj.fleet_id);
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetInstancesResult {
pub active_instances: Option<Vec<ActiveInstance>>,
pub fleet_id: Option<String>,
pub next_token: Option<String>,
}
struct DescribeFleetInstancesResultDeserializer;
impl DescribeFleetInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFleetInstancesResult, XmlParseError> {
deserialize_elements::<_, DescribeFleetInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"activeInstanceSet" => {
obj.active_instances.get_or_insert(vec![]).extend(
ActiveInstanceSetDeserializer::deserialize("activeInstanceSet", stack)?,
);
}
"fleetId" => {
obj.fleet_id =
Some(FleetIdentifierDeserializer::deserialize("fleetId", stack)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct DescribeFleetsErrorSetDeserializer;
impl DescribeFleetsErrorSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DescribeFleetError>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DescribeFleetErrorDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetsInstances {
pub instance_ids: Option<Vec<String>>,
pub instance_type: Option<String>,
pub launch_template_and_overrides: Option<LaunchTemplateAndOverridesResponse>,
pub lifecycle: Option<String>,
pub platform: Option<String>,
}
struct DescribeFleetsInstancesDeserializer;
impl DescribeFleetsInstancesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFleetsInstances, XmlParseError> {
deserialize_elements::<_, DescribeFleetsInstances, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instanceIds" => {
obj.instance_ids.get_or_insert(vec![]).extend(
InstanceIdsSetDeserializer::deserialize("instanceIds", stack)?,
);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"launchTemplateAndOverrides" => {
obj.launch_template_and_overrides =
Some(LaunchTemplateAndOverridesResponseDeserializer::deserialize(
"launchTemplateAndOverrides",
stack,
)?);
}
"lifecycle" => {
obj.lifecycle = Some(InstanceLifecycleDeserializer::deserialize(
"lifecycle",
stack,
)?);
}
"platform" => {
obj.platform =
Some(PlatformValuesDeserializer::deserialize("platform", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct DescribeFleetsInstancesSetDeserializer;
impl DescribeFleetsInstancesSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DescribeFleetsInstances>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DescribeFleetsInstancesDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub fleet_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeFleetsRequestSerializer;
impl DescribeFleetsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeFleetsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.fleet_ids {
FleetIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "FleetId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFleetsResult {
pub fleets: Option<Vec<FleetData>>,
pub next_token: Option<String>,
}
struct DescribeFleetsResultDeserializer;
impl DescribeFleetsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFleetsResult, XmlParseError> {
deserialize_elements::<_, DescribeFleetsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"fleetSet" => {
obj.fleets
.get_or_insert(vec![])
.extend(FleetSetDeserializer::deserialize("fleetSet", stack)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFlowLogsRequest {
pub dry_run: Option<bool>,
pub filter: Option<Vec<Filter>>,
pub flow_log_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeFlowLogsRequestSerializer;
impl DescribeFlowLogsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeFlowLogsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filter {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.flow_log_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "FlowLogId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFlowLogsResult {
pub flow_logs: Option<Vec<FlowLog>>,
pub next_token: Option<String>,
}
struct DescribeFlowLogsResultDeserializer;
impl DescribeFlowLogsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFlowLogsResult, XmlParseError> {
deserialize_elements::<_, DescribeFlowLogsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"flowLogSet" => {
obj.flow_logs
.get_or_insert(vec![])
.extend(FlowLogSetDeserializer::deserialize("flowLogSet", stack)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFpgaImageAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub fpga_image_id: String,
}
struct DescribeFpgaImageAttributeRequestSerializer;
impl DescribeFpgaImageAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeFpgaImageAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "FpgaImageId"), &obj.fpga_image_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFpgaImageAttributeResult {
pub fpga_image_attribute: Option<FpgaImageAttribute>,
}
struct DescribeFpgaImageAttributeResultDeserializer;
impl DescribeFpgaImageAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFpgaImageAttributeResult, XmlParseError> {
deserialize_elements::<_, DescribeFpgaImageAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"fpgaImageAttribute" => {
obj.fpga_image_attribute =
Some(FpgaImageAttributeDeserializer::deserialize(
"fpgaImageAttribute",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFpgaImagesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub fpga_image_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub owners: Option<Vec<String>>,
}
struct DescribeFpgaImagesRequestSerializer;
impl DescribeFpgaImagesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeFpgaImagesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.fpga_image_ids {
FpgaImageIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "FpgaImageId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.owners {
OwnerStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "Owner"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeFpgaImagesResult {
pub fpga_images: Option<Vec<FpgaImage>>,
pub next_token: Option<String>,
}
struct DescribeFpgaImagesResultDeserializer;
impl DescribeFpgaImagesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeFpgaImagesResult, XmlParseError> {
deserialize_elements::<_, DescribeFpgaImagesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"fpgaImageSet" => {
obj.fpga_images.get_or_insert(vec![]).extend(
FpgaImageListDeserializer::deserialize("fpgaImageSet", stack)?,
);
}
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeHostReservationOfferingsRequest {
pub filter: Option<Vec<Filter>>,
pub max_duration: Option<i64>,
pub max_results: Option<i64>,
pub min_duration: Option<i64>,
pub next_token: Option<String>,
pub offering_id: Option<String>,
}
struct DescribeHostReservationOfferingsRequestSerializer;
impl DescribeHostReservationOfferingsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeHostReservationOfferingsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filter {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_duration {
params.put(&format!("{}{}", prefix, "MaxDuration"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.min_duration {
params.put(&format!("{}{}", prefix, "MinDuration"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.offering_id {
params.put(&format!("{}{}", prefix, "OfferingId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeHostReservationOfferingsResult {
pub next_token: Option<String>,
pub offering_set: Option<Vec<HostOffering>>,
}
struct DescribeHostReservationOfferingsResultDeserializer;
impl DescribeHostReservationOfferingsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeHostReservationOfferingsResult, XmlParseError> {
deserialize_elements::<_, DescribeHostReservationOfferingsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"offeringSet" => {
obj.offering_set.get_or_insert(vec![]).extend(
HostOfferingSetDeserializer::deserialize("offeringSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeHostReservationsRequest {
pub filter: Option<Vec<Filter>>,
pub host_reservation_id_set: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeHostReservationsRequestSerializer;
impl DescribeHostReservationsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeHostReservationsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filter {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.host_reservation_id_set {
HostReservationIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "HostReservationIdSet"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeHostReservationsResult {
pub host_reservation_set: Option<Vec<HostReservation>>,
pub next_token: Option<String>,
}
struct DescribeHostReservationsResultDeserializer;
impl DescribeHostReservationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeHostReservationsResult, XmlParseError> {
deserialize_elements::<_, DescribeHostReservationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"hostReservationSet" => {
obj.host_reservation_set.get_or_insert(vec![]).extend(
HostReservationSetDeserializer::deserialize(
"hostReservationSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeHostsRequest {
pub filter: Option<Vec<Filter>>,
pub host_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeHostsRequestSerializer;
impl DescribeHostsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeHostsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filter {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.host_ids {
RequestHostIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "HostId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeHostsResult {
pub hosts: Option<Vec<Host>>,
pub next_token: Option<String>,
}
struct DescribeHostsResultDeserializer;
impl DescribeHostsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeHostsResult, XmlParseError> {
deserialize_elements::<_, DescribeHostsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"hostSet" => {
obj.hosts
.get_or_insert(vec![])
.extend(HostListDeserializer::deserialize("hostSet", stack)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeIamInstanceProfileAssociationsRequest {
pub association_ids: Option<Vec<String>>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeIamInstanceProfileAssociationsRequestSerializer;
impl DescribeIamInstanceProfileAssociationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeIamInstanceProfileAssociationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.association_ids {
AssociationIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "AssociationId"),
field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeIamInstanceProfileAssociationsResult {
pub iam_instance_profile_associations: Option<Vec<IamInstanceProfileAssociation>>,
pub next_token: Option<String>,
}
struct DescribeIamInstanceProfileAssociationsResultDeserializer;
impl DescribeIamInstanceProfileAssociationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeIamInstanceProfileAssociationsResult, XmlParseError> {
deserialize_elements::<_, DescribeIamInstanceProfileAssociationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"iamInstanceProfileAssociationSet" => {
obj.iam_instance_profile_associations
.get_or_insert(vec![])
.extend(IamInstanceProfileAssociationSetDeserializer::deserialize(
"iamInstanceProfileAssociationSet",
stack,
)?);
}
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeIdFormatRequest {
pub resource: Option<String>,
}
struct DescribeIdFormatRequestSerializer;
impl DescribeIdFormatRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeIdFormatRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.resource {
params.put(&format!("{}{}", prefix, "Resource"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeIdFormatResult {
pub statuses: Option<Vec<IdFormat>>,
}
struct DescribeIdFormatResultDeserializer;
impl DescribeIdFormatResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeIdFormatResult, XmlParseError> {
deserialize_elements::<_, DescribeIdFormatResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"statusSet" => {
obj.statuses
.get_or_insert(vec![])
.extend(IdFormatListDeserializer::deserialize("statusSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeIdentityIdFormatRequest {
pub principal_arn: String,
pub resource: Option<String>,
}
struct DescribeIdentityIdFormatRequestSerializer;
impl DescribeIdentityIdFormatRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeIdentityIdFormatRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "PrincipalArn"), &obj.principal_arn);
if let Some(ref field_value) = obj.resource {
params.put(&format!("{}{}", prefix, "Resource"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeIdentityIdFormatResult {
pub statuses: Option<Vec<IdFormat>>,
}
struct DescribeIdentityIdFormatResultDeserializer;
impl DescribeIdentityIdFormatResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeIdentityIdFormatResult, XmlParseError> {
deserialize_elements::<_, DescribeIdentityIdFormatResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"statusSet" => {
obj.statuses
.get_or_insert(vec![])
.extend(IdFormatListDeserializer::deserialize("statusSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImageAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub image_id: String,
}
struct DescribeImageAttributeRequestSerializer;
impl DescribeImageAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeImageAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "ImageId"), &obj.image_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImagesRequest {
pub dry_run: Option<bool>,
pub executable_users: Option<Vec<String>>,
pub filters: Option<Vec<Filter>>,
pub image_ids: Option<Vec<String>>,
pub owners: Option<Vec<String>>,
}
struct DescribeImagesRequestSerializer;
impl DescribeImagesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeImagesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.executable_users {
ExecutableByStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ExecutableBy"),
field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.image_ids {
ImageIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ImageId"),
field_value,
);
}
if let Some(ref field_value) = obj.owners {
OwnerStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "Owner"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImagesResult {
pub images: Option<Vec<Image>>,
}
struct DescribeImagesResultDeserializer;
impl DescribeImagesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeImagesResult, XmlParseError> {
deserialize_elements::<_, DescribeImagesResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"imagesSet" => {
obj.images
.get_or_insert(vec![])
.extend(ImageListDeserializer::deserialize("imagesSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImportImageTasksRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub import_task_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeImportImageTasksRequestSerializer;
impl DescribeImportImageTasksRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeImportImageTasksRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filters"),
field_value,
);
}
if let Some(ref field_value) = obj.import_task_ids {
ImportTaskIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ImportTaskId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImportImageTasksResult {
pub import_image_tasks: Option<Vec<ImportImageTask>>,
pub next_token: Option<String>,
}
struct DescribeImportImageTasksResultDeserializer;
impl DescribeImportImageTasksResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeImportImageTasksResult, XmlParseError> {
deserialize_elements::<_, DescribeImportImageTasksResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"importImageTaskSet" => {
obj.import_image_tasks.get_or_insert(vec![]).extend(
ImportImageTaskListDeserializer::deserialize(
"importImageTaskSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImportSnapshotTasksRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub import_task_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeImportSnapshotTasksRequestSerializer;
impl DescribeImportSnapshotTasksRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeImportSnapshotTasksRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filters"),
field_value,
);
}
if let Some(ref field_value) = obj.import_task_ids {
ImportTaskIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ImportTaskId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeImportSnapshotTasksResult {
pub import_snapshot_tasks: Option<Vec<ImportSnapshotTask>>,
pub next_token: Option<String>,
}
struct DescribeImportSnapshotTasksResultDeserializer;
impl DescribeImportSnapshotTasksResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeImportSnapshotTasksResult, XmlParseError> {
deserialize_elements::<_, DescribeImportSnapshotTasksResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"importSnapshotTaskSet" => {
obj.import_snapshot_tasks.get_or_insert(vec![]).extend(
ImportSnapshotTaskListDeserializer::deserialize(
"importSnapshotTaskSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstanceAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub instance_id: String,
}
struct DescribeInstanceAttributeRequestSerializer;
impl DescribeInstanceAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeInstanceAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstanceCreditSpecificationsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub instance_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeInstanceCreditSpecificationsRequestSerializer;
impl DescribeInstanceCreditSpecificationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeInstanceCreditSpecificationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_ids {
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstanceCreditSpecificationsResult {
pub instance_credit_specifications: Option<Vec<InstanceCreditSpecification>>,
pub next_token: Option<String>,
}
struct DescribeInstanceCreditSpecificationsResultDeserializer;
impl DescribeInstanceCreditSpecificationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeInstanceCreditSpecificationsResult, XmlParseError> {
deserialize_elements::<_, DescribeInstanceCreditSpecificationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instanceCreditSpecificationSet" => {
obj.instance_credit_specifications
.get_or_insert(vec![])
.extend(InstanceCreditSpecificationListDeserializer::deserialize(
"instanceCreditSpecificationSet",
stack,
)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstanceStatusRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub include_all_instances: Option<bool>,
pub instance_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeInstanceStatusRequestSerializer;
impl DescribeInstanceStatusRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeInstanceStatusRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.include_all_instances {
params.put(
&format!("{}{}", prefix, "IncludeAllInstances"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_ids {
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstanceStatusResult {
pub instance_statuses: Option<Vec<InstanceStatus>>,
pub next_token: Option<String>,
}
struct DescribeInstanceStatusResultDeserializer;
impl DescribeInstanceStatusResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeInstanceStatusResult, XmlParseError> {
deserialize_elements::<_, DescribeInstanceStatusResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instanceStatusSet" => {
obj.instance_statuses.get_or_insert(vec![]).extend(
InstanceStatusListDeserializer::deserialize(
"instanceStatusSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstancesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub instance_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeInstancesRequestSerializer;
impl DescribeInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_ids {
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInstancesResult {
pub next_token: Option<String>,
pub reservations: Option<Vec<Reservation>>,
}
struct DescribeInstancesResultDeserializer;
impl DescribeInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeInstancesResult, XmlParseError> {
deserialize_elements::<_, DescribeInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"reservationSet" => {
obj.reservations.get_or_insert(vec![]).extend(
ReservationListDeserializer::deserialize("reservationSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInternetGatewaysRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub internet_gateway_ids: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeInternetGatewaysRequestSerializer;
impl DescribeInternetGatewaysRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeInternetGatewaysRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.internet_gateway_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InternetGatewayId"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeInternetGatewaysResult {
pub internet_gateways: Option<Vec<InternetGateway>>,
pub next_token: Option<String>,
}
struct DescribeInternetGatewaysResultDeserializer;
impl DescribeInternetGatewaysResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeInternetGatewaysResult, XmlParseError> {
deserialize_elements::<_, DescribeInternetGatewaysResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"internetGatewaySet" => {
obj.internet_gateways.get_or_insert(vec![]).extend(
InternetGatewayListDeserializer::deserialize(
"internetGatewaySet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeKeyPairsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub key_names: Option<Vec<String>>,
}
struct DescribeKeyPairsRequestSerializer;
impl DescribeKeyPairsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeKeyPairsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.key_names {
KeyNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "KeyName"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeKeyPairsResult {
pub key_pairs: Option<Vec<KeyPairInfo>>,
}
struct DescribeKeyPairsResultDeserializer;
impl DescribeKeyPairsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeKeyPairsResult, XmlParseError> {
deserialize_elements::<_, DescribeKeyPairsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"keySet" => {
obj.key_pairs
.get_or_insert(vec![])
.extend(KeyPairListDeserializer::deserialize("keySet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLaunchTemplateVersionsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub max_results: Option<i64>,
pub max_version: Option<String>,
pub min_version: Option<String>,
pub next_token: Option<String>,
pub versions: Option<Vec<String>>,
}
struct DescribeLaunchTemplateVersionsRequestSerializer;
impl DescribeLaunchTemplateVersionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeLaunchTemplateVersionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.max_version {
params.put(&format!("{}{}", prefix, "MaxVersion"), &field_value);
}
if let Some(ref field_value) = obj.min_version {
params.put(&format!("{}{}", prefix, "MinVersion"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.versions {
VersionStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateVersion"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLaunchTemplateVersionsResult {
pub launch_template_versions: Option<Vec<LaunchTemplateVersion>>,
pub next_token: Option<String>,
}
struct DescribeLaunchTemplateVersionsResultDeserializer;
impl DescribeLaunchTemplateVersionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeLaunchTemplateVersionsResult, XmlParseError> {
deserialize_elements::<_, DescribeLaunchTemplateVersionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateVersionSet" => {
obj.launch_template_versions.get_or_insert(vec![]).extend(
LaunchTemplateVersionSetDeserializer::deserialize(
"launchTemplateVersionSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLaunchTemplatesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub launch_template_ids: Option<Vec<String>>,
pub launch_template_names: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeLaunchTemplatesRequestSerializer;
impl DescribeLaunchTemplatesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeLaunchTemplatesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.launch_template_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateId"),
field_value,
);
}
if let Some(ref field_value) = obj.launch_template_names {
LaunchTemplateNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateName"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLaunchTemplatesResult {
pub launch_templates: Option<Vec<LaunchTemplate>>,
pub next_token: Option<String>,
}
struct DescribeLaunchTemplatesResultDeserializer;
impl DescribeLaunchTemplatesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeLaunchTemplatesResult, XmlParseError> {
deserialize_elements::<_, DescribeLaunchTemplatesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplates" => {
obj.launch_templates.get_or_insert(vec![]).extend(
LaunchTemplateSetDeserializer::deserialize("launchTemplates", stack)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeMovingAddressesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub public_ips: Option<Vec<String>>,
}
struct DescribeMovingAddressesRequestSerializer;
impl DescribeMovingAddressesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeMovingAddressesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.public_ips {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "PublicIp"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeMovingAddressesResult {
pub moving_address_statuses: Option<Vec<MovingAddressStatus>>,
pub next_token: Option<String>,
}
struct DescribeMovingAddressesResultDeserializer;
impl DescribeMovingAddressesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeMovingAddressesResult, XmlParseError> {
deserialize_elements::<_, DescribeMovingAddressesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"movingAddressStatusSet" => {
obj.moving_address_statuses.get_or_insert(vec![]).extend(
MovingAddressStatusSetDeserializer::deserialize(
"movingAddressStatusSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNatGatewaysRequest {
pub filter: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub nat_gateway_ids: Option<Vec<String>>,
pub next_token: Option<String>,
}
struct DescribeNatGatewaysRequestSerializer;
impl DescribeNatGatewaysRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeNatGatewaysRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filter {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.nat_gateway_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "NatGatewayId"),
field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNatGatewaysResult {
pub nat_gateways: Option<Vec<NatGateway>>,
pub next_token: Option<String>,
}
struct DescribeNatGatewaysResultDeserializer;
impl DescribeNatGatewaysResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeNatGatewaysResult, XmlParseError> {
deserialize_elements::<_, DescribeNatGatewaysResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"natGatewaySet" => {
obj.nat_gateways.get_or_insert(vec![]).extend(
NatGatewayListDeserializer::deserialize("natGatewaySet", stack)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkAclsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub network_acl_ids: Option<Vec<String>>,
pub next_token: Option<String>,
}
struct DescribeNetworkAclsRequestSerializer;
impl DescribeNetworkAclsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeNetworkAclsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.network_acl_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkAclId"),
field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkAclsResult {
pub network_acls: Option<Vec<NetworkAcl>>,
pub next_token: Option<String>,
}
struct DescribeNetworkAclsResultDeserializer;
impl DescribeNetworkAclsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeNetworkAclsResult, XmlParseError> {
deserialize_elements::<_, DescribeNetworkAclsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"networkAclSet" => {
obj.network_acls.get_or_insert(vec![]).extend(
NetworkAclListDeserializer::deserialize("networkAclSet", stack)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkInterfaceAttributeRequest {
pub attribute: Option<String>,
pub dry_run: Option<bool>,
pub network_interface_id: String,
}
struct DescribeNetworkInterfaceAttributeRequestSerializer;
impl DescribeNetworkInterfaceAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeNetworkInterfaceAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute {
params.put(&format!("{}{}", prefix, "Attribute"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkInterfaceAttributeResult {
pub attachment: Option<NetworkInterfaceAttachment>,
pub description: Option<AttributeValue>,
pub groups: Option<Vec<GroupIdentifier>>,
pub network_interface_id: Option<String>,
pub source_dest_check: Option<AttributeBooleanValue>,
}
struct DescribeNetworkInterfaceAttributeResultDeserializer;
impl DescribeNetworkInterfaceAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeNetworkInterfaceAttributeResult, XmlParseError> {
deserialize_elements::<_, DescribeNetworkInterfaceAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"attachment" => {
obj.attachment = Some(NetworkInterfaceAttachmentDeserializer::deserialize(
"attachment",
stack,
)?);
}
"description" => {
obj.description = Some(AttributeValueDeserializer::deserialize(
"description",
stack,
)?);
}
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"sourceDestCheck" => {
obj.source_dest_check =
Some(AttributeBooleanValueDeserializer::deserialize(
"sourceDestCheck",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkInterfacePermissionsRequest {
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub network_interface_permission_ids: Option<Vec<String>>,
pub next_token: Option<String>,
}
struct DescribeNetworkInterfacePermissionsRequestSerializer;
impl DescribeNetworkInterfacePermissionsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeNetworkInterfacePermissionsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.network_interface_permission_ids {
NetworkInterfacePermissionIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterfacePermissionId"),
field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkInterfacePermissionsResult {
pub network_interface_permissions: Option<Vec<NetworkInterfacePermission>>,
pub next_token: Option<String>,
}
struct DescribeNetworkInterfacePermissionsResultDeserializer;
impl DescribeNetworkInterfacePermissionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeNetworkInterfacePermissionsResult, XmlParseError> {
deserialize_elements::<_, DescribeNetworkInterfacePermissionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"networkInterfacePermissions" => {
obj.network_interface_permissions
.get_or_insert(vec![])
.extend(NetworkInterfacePermissionListDeserializer::deserialize(
"networkInterfacePermissions",
stack,
)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkInterfacesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub network_interface_ids: Option<Vec<String>>,
pub next_token: Option<String>,
}
struct DescribeNetworkInterfacesRequestSerializer;
impl DescribeNetworkInterfacesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeNetworkInterfacesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.network_interface_ids {
NetworkInterfaceIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterfaceId"),
field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeNetworkInterfacesResult {
pub network_interfaces: Option<Vec<NetworkInterface>>,
pub next_token: Option<String>,
}
struct DescribeNetworkInterfacesResultDeserializer;
impl DescribeNetworkInterfacesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeNetworkInterfacesResult, XmlParseError> {
deserialize_elements::<_, DescribeNetworkInterfacesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"networkInterfaceSet" => {
obj.network_interfaces.get_or_insert(vec![]).extend(
NetworkInterfaceListDeserializer::deserialize(
"networkInterfaceSet",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePlacementGroupsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub group_names: Option<Vec<String>>,
}
struct DescribePlacementGroupsRequestSerializer;
impl DescribePlacementGroupsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribePlacementGroupsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.group_names {
PlacementGroupStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupName"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePlacementGroupsResult {
pub placement_groups: Option<Vec<PlacementGroup>>,
}
struct DescribePlacementGroupsResultDeserializer;
impl DescribePlacementGroupsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribePlacementGroupsResult, XmlParseError> {
deserialize_elements::<_, DescribePlacementGroupsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"placementGroupSet" => {
obj.placement_groups.get_or_insert(vec![]).extend(
PlacementGroupListDeserializer::deserialize(
"placementGroupSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePrefixListsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub prefix_list_ids: Option<Vec<String>>,
}
struct DescribePrefixListsRequestSerializer;
impl DescribePrefixListsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribePrefixListsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.prefix_list_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrefixListId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePrefixListsResult {
pub next_token: Option<String>,
pub prefix_lists: Option<Vec<PrefixList>>,
}
struct DescribePrefixListsResultDeserializer;
impl DescribePrefixListsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribePrefixListsResult, XmlParseError> {
deserialize_elements::<_, DescribePrefixListsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"prefixListSet" => {
obj.prefix_lists.get_or_insert(vec![]).extend(
PrefixListSetDeserializer::deserialize("prefixListSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePrincipalIdFormatRequest {
pub dry_run: Option<bool>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub resources: Option<Vec<String>>,
}
struct DescribePrincipalIdFormatRequestSerializer;
impl DescribePrincipalIdFormatRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribePrincipalIdFormatRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.resources {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "Resource"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePrincipalIdFormatResult {
pub next_token: Option<String>,
pub principals: Option<Vec<PrincipalIdFormat>>,
}
struct DescribePrincipalIdFormatResultDeserializer;
impl DescribePrincipalIdFormatResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribePrincipalIdFormatResult, XmlParseError> {
deserialize_elements::<_, DescribePrincipalIdFormatResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"principalSet" => {
obj.principals.get_or_insert(vec![]).extend(
PrincipalIdFormatListDeserializer::deserialize("principalSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePublicIpv4PoolsRequest {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub pool_ids: Option<Vec<String>>,
}
struct DescribePublicIpv4PoolsRequestSerializer;
impl DescribePublicIpv4PoolsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribePublicIpv4PoolsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.pool_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "PoolId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePublicIpv4PoolsResult {
pub next_token: Option<String>,
pub public_ipv_4_pools: Option<Vec<PublicIpv4Pool>>,
}
struct DescribePublicIpv4PoolsResultDeserializer;
impl DescribePublicIpv4PoolsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribePublicIpv4PoolsResult, XmlParseError> {
deserialize_elements::<_, DescribePublicIpv4PoolsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"publicIpv4PoolSet" => {
obj.public_ipv_4_pools.get_or_insert(vec![]).extend(
PublicIpv4PoolSetDeserializer::deserialize("publicIpv4PoolSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeRegionsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub region_names: Option<Vec<String>>,
}
struct DescribeRegionsRequestSerializer;
impl DescribeRegionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeRegionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.region_names {
RegionNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RegionName"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeRegionsResult {
pub regions: Option<Vec<Region>>,
}
struct DescribeRegionsResultDeserializer;
impl DescribeRegionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeRegionsResult, XmlParseError> {
deserialize_elements::<_, DescribeRegionsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"regionInfo" => {
obj.regions
.get_or_insert(vec![])
.extend(RegionListDeserializer::deserialize("regionInfo", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesListingsRequest {
pub filters: Option<Vec<Filter>>,
pub reserved_instances_id: Option<String>,
pub reserved_instances_listing_id: Option<String>,
}
struct DescribeReservedInstancesListingsRequestSerializer;
impl DescribeReservedInstancesListingsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReservedInstancesListingsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.reserved_instances_id {
params.put(
&format!("{}{}", prefix, "ReservedInstancesId"),
&field_value,
);
}
if let Some(ref field_value) = obj.reserved_instances_listing_id {
params.put(
&format!("{}{}", prefix, "ReservedInstancesListingId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesListingsResult {
pub reserved_instances_listings: Option<Vec<ReservedInstancesListing>>,
}
struct DescribeReservedInstancesListingsResultDeserializer;
impl DescribeReservedInstancesListingsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeReservedInstancesListingsResult, XmlParseError> {
deserialize_elements::<_, DescribeReservedInstancesListingsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesListingsSet" => {
obj.reserved_instances_listings
.get_or_insert(vec![])
.extend(ReservedInstancesListingListDeserializer::deserialize(
"reservedInstancesListingsSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesModificationsRequest {
pub filters: Option<Vec<Filter>>,
pub next_token: Option<String>,
pub reserved_instances_modification_ids: Option<Vec<String>>,
}
struct DescribeReservedInstancesModificationsRequestSerializer;
impl DescribeReservedInstancesModificationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeReservedInstancesModificationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.reserved_instances_modification_ids {
ReservedInstancesModificationIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstancesModificationId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesModificationsResult {
pub next_token: Option<String>,
pub reserved_instances_modifications: Option<Vec<ReservedInstancesModification>>,
}
struct DescribeReservedInstancesModificationsResultDeserializer;
impl DescribeReservedInstancesModificationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeReservedInstancesModificationsResult, XmlParseError> {
deserialize_elements::<_, DescribeReservedInstancesModificationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"reservedInstancesModificationsSet" => {
obj.reserved_instances_modifications
.get_or_insert(vec![])
.extend(ReservedInstancesModificationListDeserializer::deserialize(
"reservedInstancesModificationsSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesOfferingsRequest {
pub availability_zone: Option<String>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub include_marketplace: Option<bool>,
pub instance_tenancy: Option<String>,
pub instance_type: Option<String>,
pub max_duration: Option<i64>,
pub max_instance_count: Option<i64>,
pub max_results: Option<i64>,
pub min_duration: Option<i64>,
pub next_token: Option<String>,
pub offering_class: Option<String>,
pub offering_type: Option<String>,
pub product_description: Option<String>,
pub reserved_instances_offering_ids: Option<Vec<String>>,
}
struct DescribeReservedInstancesOfferingsRequestSerializer;
impl DescribeReservedInstancesOfferingsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReservedInstancesOfferingsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.include_marketplace {
params.put(&format!("{}{}", prefix, "IncludeMarketplace"), &field_value);
}
if let Some(ref field_value) = obj.instance_tenancy {
params.put(&format!("{}{}", prefix, "InstanceTenancy"), &field_value);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.max_duration {
params.put(&format!("{}{}", prefix, "MaxDuration"), &field_value);
}
if let Some(ref field_value) = obj.max_instance_count {
params.put(&format!("{}{}", prefix, "MaxInstanceCount"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.min_duration {
params.put(&format!("{}{}", prefix, "MinDuration"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.offering_class {
params.put(&format!("{}{}", prefix, "OfferingClass"), &field_value);
}
if let Some(ref field_value) = obj.offering_type {
params.put(&format!("{}{}", prefix, "OfferingType"), &field_value);
}
if let Some(ref field_value) = obj.product_description {
params.put(&format!("{}{}", prefix, "ProductDescription"), &field_value);
}
if let Some(ref field_value) = obj.reserved_instances_offering_ids {
ReservedInstancesOfferingIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstancesOfferingId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesOfferingsResult {
pub next_token: Option<String>,
pub reserved_instances_offerings: Option<Vec<ReservedInstancesOffering>>,
}
struct DescribeReservedInstancesOfferingsResultDeserializer;
impl DescribeReservedInstancesOfferingsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeReservedInstancesOfferingsResult, XmlParseError> {
deserialize_elements::<_, DescribeReservedInstancesOfferingsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"reservedInstancesOfferingsSet" => {
obj.reserved_instances_offerings
.get_or_insert(vec![])
.extend(ReservedInstancesOfferingListDeserializer::deserialize(
"reservedInstancesOfferingsSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub offering_class: Option<String>,
pub offering_type: Option<String>,
pub reserved_instances_ids: Option<Vec<String>>,
}
struct DescribeReservedInstancesRequestSerializer;
impl DescribeReservedInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReservedInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.offering_class {
params.put(&format!("{}{}", prefix, "OfferingClass"), &field_value);
}
if let Some(ref field_value) = obj.offering_type {
params.put(&format!("{}{}", prefix, "OfferingType"), &field_value);
}
if let Some(ref field_value) = obj.reserved_instances_ids {
ReservedInstancesIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstancesId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeReservedInstancesResult {
pub reserved_instances: Option<Vec<ReservedInstances>>,
}
struct DescribeReservedInstancesResultDeserializer;
impl DescribeReservedInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeReservedInstancesResult, XmlParseError> {
deserialize_elements::<_, DescribeReservedInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesSet" => {
obj.reserved_instances.get_or_insert(vec![]).extend(
ReservedInstancesListDeserializer::deserialize(
"reservedInstancesSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeRouteTablesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub route_table_ids: Option<Vec<String>>,
}
struct DescribeRouteTablesRequestSerializer;
impl DescribeRouteTablesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeRouteTablesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.route_table_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RouteTableId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeRouteTablesResult {
pub next_token: Option<String>,
pub route_tables: Option<Vec<RouteTable>>,
}
struct DescribeRouteTablesResultDeserializer;
impl DescribeRouteTablesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeRouteTablesResult, XmlParseError> {
deserialize_elements::<_, DescribeRouteTablesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"routeTableSet" => {
obj.route_tables.get_or_insert(vec![]).extend(
RouteTableListDeserializer::deserialize("routeTableSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeScheduledInstanceAvailabilityRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub first_slot_start_time_range: SlotDateTimeRangeRequest,
pub max_results: Option<i64>,
pub max_slot_duration_in_hours: Option<i64>,
pub min_slot_duration_in_hours: Option<i64>,
pub next_token: Option<String>,
pub recurrence: ScheduledInstanceRecurrenceRequest,
}
struct DescribeScheduledInstanceAvailabilityRequestSerializer;
impl DescribeScheduledInstanceAvailabilityRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeScheduledInstanceAvailabilityRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
SlotDateTimeRangeRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "FirstSlotStartTimeRange"),
&obj.first_slot_start_time_range,
);
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.max_slot_duration_in_hours {
params.put(
&format!("{}{}", prefix, "MaxSlotDurationInHours"),
&field_value,
);
}
if let Some(ref field_value) = obj.min_slot_duration_in_hours {
params.put(
&format!("{}{}", prefix, "MinSlotDurationInHours"),
&field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
ScheduledInstanceRecurrenceRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Recurrence"),
&obj.recurrence,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeScheduledInstanceAvailabilityResult {
pub next_token: Option<String>,
pub scheduled_instance_availability_set: Option<Vec<ScheduledInstanceAvailability>>,
}
struct DescribeScheduledInstanceAvailabilityResultDeserializer;
impl DescribeScheduledInstanceAvailabilityResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeScheduledInstanceAvailabilityResult, XmlParseError> {
deserialize_elements::<_, DescribeScheduledInstanceAvailabilityResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"scheduledInstanceAvailabilitySet" => {
obj.scheduled_instance_availability_set
.get_or_insert(vec![])
.extend(ScheduledInstanceAvailabilitySetDeserializer::deserialize(
"scheduledInstanceAvailabilitySet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeScheduledInstancesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub scheduled_instance_ids: Option<Vec<String>>,
pub slot_start_time_range: Option<SlotStartTimeRangeRequest>,
}
struct DescribeScheduledInstancesRequestSerializer;
impl DescribeScheduledInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeScheduledInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.scheduled_instance_ids {
ScheduledInstanceIdRequestSetSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduledInstanceId"),
field_value,
);
}
if let Some(ref field_value) = obj.slot_start_time_range {
SlotStartTimeRangeRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "SlotStartTimeRange"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeScheduledInstancesResult {
pub next_token: Option<String>,
pub scheduled_instance_set: Option<Vec<ScheduledInstance>>,
}
struct DescribeScheduledInstancesResultDeserializer;
impl DescribeScheduledInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeScheduledInstancesResult, XmlParseError> {
deserialize_elements::<_, DescribeScheduledInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"scheduledInstanceSet" => {
obj.scheduled_instance_set.get_or_insert(vec![]).extend(
ScheduledInstanceSetDeserializer::deserialize(
"scheduledInstanceSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSecurityGroupReferencesRequest {
pub dry_run: Option<bool>,
pub group_id: Vec<String>,
}
struct DescribeSecurityGroupReferencesRequestSerializer;
impl DescribeSecurityGroupReferencesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSecurityGroupReferencesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
GroupIdsSerializer::serialize(params, &format!("{}{}", prefix, "GroupId"), &obj.group_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSecurityGroupReferencesResult {
pub security_group_reference_set: Option<Vec<SecurityGroupReference>>,
}
struct DescribeSecurityGroupReferencesResultDeserializer;
impl DescribeSecurityGroupReferencesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSecurityGroupReferencesResult, XmlParseError> {
deserialize_elements::<_, DescribeSecurityGroupReferencesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"securityGroupReferenceSet" => {
obj.security_group_reference_set
.get_or_insert(vec![])
.extend(SecurityGroupReferencesDeserializer::deserialize(
"securityGroupReferenceSet",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSecurityGroupsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub group_ids: Option<Vec<String>>,
pub group_names: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeSecurityGroupsRequestSerializer;
impl DescribeSecurityGroupsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSecurityGroupsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.group_ids {
GroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.group_names {
GroupNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSecurityGroupsResult {
pub next_token: Option<String>,
pub security_groups: Option<Vec<SecurityGroup>>,
}
struct DescribeSecurityGroupsResultDeserializer;
impl DescribeSecurityGroupsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSecurityGroupsResult, XmlParseError> {
deserialize_elements::<_, DescribeSecurityGroupsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"securityGroupInfo" => {
obj.security_groups.get_or_insert(vec![]).extend(
SecurityGroupListDeserializer::deserialize("securityGroupInfo", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSnapshotAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub snapshot_id: String,
}
struct DescribeSnapshotAttributeRequestSerializer;
impl DescribeSnapshotAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSnapshotAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "SnapshotId"), &obj.snapshot_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSnapshotAttributeResult {
pub create_volume_permissions: Option<Vec<CreateVolumePermission>>,
pub product_codes: Option<Vec<ProductCode>>,
pub snapshot_id: Option<String>,
}
struct DescribeSnapshotAttributeResultDeserializer;
impl DescribeSnapshotAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSnapshotAttributeResult, XmlParseError> {
deserialize_elements::<_, DescribeSnapshotAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"createVolumePermission" => {
obj.create_volume_permissions.get_or_insert(vec![]).extend(
CreateVolumePermissionListDeserializer::deserialize(
"createVolumePermission",
stack,
)?,
);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"snapshotId" => {
obj.snapshot_id =
Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSnapshotsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub owner_ids: Option<Vec<String>>,
pub restorable_by_user_ids: Option<Vec<String>>,
pub snapshot_ids: Option<Vec<String>>,
}
struct DescribeSnapshotsRequestSerializer;
impl DescribeSnapshotsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSnapshotsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.owner_ids {
OwnerStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "Owner"),
field_value,
);
}
if let Some(ref field_value) = obj.restorable_by_user_ids {
RestorableByStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RestorableBy"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_ids {
SnapshotIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SnapshotId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSnapshotsResult {
pub next_token: Option<String>,
pub snapshots: Option<Vec<Snapshot>>,
}
struct DescribeSnapshotsResultDeserializer;
impl DescribeSnapshotsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSnapshotsResult, XmlParseError> {
deserialize_elements::<_, DescribeSnapshotsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"snapshotSet" => {
obj.snapshots
.get_or_insert(vec![])
.extend(SnapshotListDeserializer::deserialize("snapshotSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotDatafeedSubscriptionRequest {
pub dry_run: Option<bool>,
}
struct DescribeSpotDatafeedSubscriptionRequestSerializer;
impl DescribeSpotDatafeedSubscriptionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSpotDatafeedSubscriptionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotDatafeedSubscriptionResult {
pub spot_datafeed_subscription: Option<SpotDatafeedSubscription>,
}
struct DescribeSpotDatafeedSubscriptionResultDeserializer;
impl DescribeSpotDatafeedSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSpotDatafeedSubscriptionResult, XmlParseError> {
deserialize_elements::<_, DescribeSpotDatafeedSubscriptionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"spotDatafeedSubscription" => {
obj.spot_datafeed_subscription =
Some(SpotDatafeedSubscriptionDeserializer::deserialize(
"spotDatafeedSubscription",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotFleetInstancesRequest {
pub dry_run: Option<bool>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub spot_fleet_request_id: String,
}
struct DescribeSpotFleetInstancesRequestSerializer;
impl DescribeSpotFleetInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSpotFleetInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SpotFleetRequestId"),
&obj.spot_fleet_request_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotFleetInstancesResponse {
pub active_instances: Option<Vec<ActiveInstance>>,
pub next_token: Option<String>,
pub spot_fleet_request_id: Option<String>,
}
struct DescribeSpotFleetInstancesResponseDeserializer;
impl DescribeSpotFleetInstancesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSpotFleetInstancesResponse, XmlParseError> {
deserialize_elements::<_, DescribeSpotFleetInstancesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"activeInstanceSet" => {
obj.active_instances.get_or_insert(vec![]).extend(
ActiveInstanceSetDeserializer::deserialize("activeInstanceSet", stack)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"spotFleetRequestId" => {
obj.spot_fleet_request_id = Some(StringDeserializer::deserialize(
"spotFleetRequestId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotFleetRequestHistoryRequest {
pub dry_run: Option<bool>,
pub event_type: Option<String>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub spot_fleet_request_id: String,
pub start_time: String,
}
struct DescribeSpotFleetRequestHistoryRequestSerializer;
impl DescribeSpotFleetRequestHistoryRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSpotFleetRequestHistoryRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.event_type {
params.put(&format!("{}{}", prefix, "EventType"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SpotFleetRequestId"),
&obj.spot_fleet_request_id,
);
params.put(&format!("{}{}", prefix, "StartTime"), &obj.start_time);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotFleetRequestHistoryResponse {
pub history_records: Option<Vec<HistoryRecord>>,
pub last_evaluated_time: Option<String>,
pub next_token: Option<String>,
pub spot_fleet_request_id: Option<String>,
pub start_time: Option<String>,
}
struct DescribeSpotFleetRequestHistoryResponseDeserializer;
impl DescribeSpotFleetRequestHistoryResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSpotFleetRequestHistoryResponse, XmlParseError> {
deserialize_elements::<_, DescribeSpotFleetRequestHistoryResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"historyRecordSet" => {
obj.history_records.get_or_insert(vec![]).extend(
HistoryRecordsDeserializer::deserialize("historyRecordSet", stack)?,
);
}
"lastEvaluatedTime" => {
obj.last_evaluated_time = Some(DateTimeDeserializer::deserialize(
"lastEvaluatedTime",
stack,
)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"spotFleetRequestId" => {
obj.spot_fleet_request_id = Some(StringDeserializer::deserialize(
"spotFleetRequestId",
stack,
)?);
}
"startTime" => {
obj.start_time =
Some(DateTimeDeserializer::deserialize("startTime", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotFleetRequestsRequest {
pub dry_run: Option<bool>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub spot_fleet_request_ids: Option<Vec<String>>,
}
struct DescribeSpotFleetRequestsRequestSerializer;
impl DescribeSpotFleetRequestsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSpotFleetRequestsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.spot_fleet_request_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotFleetRequestId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotFleetRequestsResponse {
pub next_token: Option<String>,
pub spot_fleet_request_configs: Option<Vec<SpotFleetRequestConfig>>,
}
struct DescribeSpotFleetRequestsResponseDeserializer;
impl DescribeSpotFleetRequestsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSpotFleetRequestsResponse, XmlParseError> {
deserialize_elements::<_, DescribeSpotFleetRequestsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"spotFleetRequestConfigSet" => {
obj.spot_fleet_request_configs.get_or_insert(vec![]).extend(
SpotFleetRequestConfigSetDeserializer::deserialize(
"spotFleetRequestConfigSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotInstanceRequestsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub spot_instance_request_ids: Option<Vec<String>>,
}
struct DescribeSpotInstanceRequestsRequestSerializer;
impl DescribeSpotInstanceRequestsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSpotInstanceRequestsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.spot_instance_request_ids {
SpotInstanceRequestIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotInstanceRequestId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotInstanceRequestsResult {
pub next_token: Option<String>,
pub spot_instance_requests: Option<Vec<SpotInstanceRequest>>,
}
struct DescribeSpotInstanceRequestsResultDeserializer;
impl DescribeSpotInstanceRequestsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSpotInstanceRequestsResult, XmlParseError> {
deserialize_elements::<_, DescribeSpotInstanceRequestsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"spotInstanceRequestSet" => {
obj.spot_instance_requests.get_or_insert(vec![]).extend(
SpotInstanceRequestListDeserializer::deserialize(
"spotInstanceRequestSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotPriceHistoryRequest {
pub availability_zone: Option<String>,
pub dry_run: Option<bool>,
pub end_time: Option<String>,
pub filters: Option<Vec<Filter>>,
pub instance_types: Option<Vec<String>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub product_descriptions: Option<Vec<String>>,
pub start_time: Option<String>,
}
struct DescribeSpotPriceHistoryRequestSerializer;
impl DescribeSpotPriceHistoryRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSpotPriceHistoryRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_types {
InstanceTypeListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceType"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.product_descriptions {
ProductDescriptionListSerializer::serialize(
params,
&format!("{}{}", prefix, "ProductDescription"),
field_value,
);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSpotPriceHistoryResult {
pub next_token: Option<String>,
pub spot_price_history: Option<Vec<SpotPrice>>,
}
struct DescribeSpotPriceHistoryResultDeserializer;
impl DescribeSpotPriceHistoryResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSpotPriceHistoryResult, XmlParseError> {
deserialize_elements::<_, DescribeSpotPriceHistoryResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"spotPriceHistorySet" => {
obj.spot_price_history.get_or_insert(vec![]).extend(
SpotPriceHistoryListDeserializer::deserialize(
"spotPriceHistorySet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeStaleSecurityGroupsRequest {
pub dry_run: Option<bool>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub vpc_id: String,
}
struct DescribeStaleSecurityGroupsRequestSerializer;
impl DescribeStaleSecurityGroupsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStaleSecurityGroupsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeStaleSecurityGroupsResult {
pub next_token: Option<String>,
pub stale_security_group_set: Option<Vec<StaleSecurityGroup>>,
}
struct DescribeStaleSecurityGroupsResultDeserializer;
impl DescribeStaleSecurityGroupsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStaleSecurityGroupsResult, XmlParseError> {
deserialize_elements::<_, DescribeStaleSecurityGroupsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"staleSecurityGroupSet" => {
obj.stale_security_group_set.get_or_insert(vec![]).extend(
StaleSecurityGroupSetDeserializer::deserialize(
"staleSecurityGroupSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSubnetsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub subnet_ids: Option<Vec<String>>,
}
struct DescribeSubnetsRequestSerializer;
impl DescribeSubnetsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSubnetsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.subnet_ids {
SubnetIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeSubnetsResult {
pub next_token: Option<String>,
pub subnets: Option<Vec<Subnet>>,
}
struct DescribeSubnetsResultDeserializer;
impl DescribeSubnetsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSubnetsResult, XmlParseError> {
deserialize_elements::<_, DescribeSubnetsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"subnetSet" => {
obj.subnets
.get_or_insert(vec![])
.extend(SubnetListDeserializer::deserialize("subnetSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTagsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeTagsRequestSerializer;
impl DescribeTagsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTagsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTagsResult {
pub next_token: Option<String>,
pub tags: Option<Vec<TagDescription>>,
}
struct DescribeTagsResultDeserializer;
impl DescribeTagsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTagsResult, XmlParseError> {
deserialize_elements::<_, DescribeTagsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"tagSet" => {
obj.tags.get_or_insert(vec![]).extend(
TagDescriptionListDeserializer::deserialize("tagSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewayAttachmentsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_attachment_ids: Option<Vec<String>>,
}
struct DescribeTransitGatewayAttachmentsRequestSerializer;
impl DescribeTransitGatewayAttachmentsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTransitGatewayAttachmentsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_attachment_ids {
TransitGatewayAttachmentIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "TransitGatewayAttachmentIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewayAttachmentsResult {
pub next_token: Option<String>,
pub transit_gateway_attachments: Option<Vec<TransitGatewayAttachment>>,
}
struct DescribeTransitGatewayAttachmentsResultDeserializer;
impl DescribeTransitGatewayAttachmentsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTransitGatewayAttachmentsResult, XmlParseError> {
deserialize_elements::<_, DescribeTransitGatewayAttachmentsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"transitGatewayAttachments" => {
obj.transit_gateway_attachments
.get_or_insert(vec![])
.extend(TransitGatewayAttachmentListDeserializer::deserialize(
"transitGatewayAttachments",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewayRouteTablesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_route_table_ids: Option<Vec<String>>,
}
struct DescribeTransitGatewayRouteTablesRequestSerializer;
impl DescribeTransitGatewayRouteTablesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTransitGatewayRouteTablesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_route_table_ids {
TransitGatewayRouteTableIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "TransitGatewayRouteTableIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewayRouteTablesResult {
pub next_token: Option<String>,
pub transit_gateway_route_tables: Option<Vec<TransitGatewayRouteTable>>,
}
struct DescribeTransitGatewayRouteTablesResultDeserializer;
impl DescribeTransitGatewayRouteTablesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTransitGatewayRouteTablesResult, XmlParseError> {
deserialize_elements::<_, DescribeTransitGatewayRouteTablesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"transitGatewayRouteTables" => {
obj.transit_gateway_route_tables
.get_or_insert(vec![])
.extend(TransitGatewayRouteTableListDeserializer::deserialize(
"transitGatewayRouteTables",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewayVpcAttachmentsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_attachment_ids: Option<Vec<String>>,
}
struct DescribeTransitGatewayVpcAttachmentsRequestSerializer;
impl DescribeTransitGatewayVpcAttachmentsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeTransitGatewayVpcAttachmentsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_attachment_ids {
TransitGatewayAttachmentIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "TransitGatewayAttachmentIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewayVpcAttachmentsResult {
pub next_token: Option<String>,
pub transit_gateway_vpc_attachments: Option<Vec<TransitGatewayVpcAttachment>>,
}
struct DescribeTransitGatewayVpcAttachmentsResultDeserializer;
impl DescribeTransitGatewayVpcAttachmentsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTransitGatewayVpcAttachmentsResult, XmlParseError> {
deserialize_elements::<_, DescribeTransitGatewayVpcAttachmentsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"transitGatewayVpcAttachments" => {
obj.transit_gateway_vpc_attachments
.get_or_insert(vec![])
.extend(TransitGatewayVpcAttachmentListDeserializer::deserialize(
"transitGatewayVpcAttachments",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewaysRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_ids: Option<Vec<String>>,
}
struct DescribeTransitGatewaysRequestSerializer;
impl DescribeTransitGatewaysRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTransitGatewaysRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_ids {
TransitGatewayIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "TransitGatewayIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTransitGatewaysResult {
pub next_token: Option<String>,
pub transit_gateways: Option<Vec<TransitGateway>>,
}
struct DescribeTransitGatewaysResultDeserializer;
impl DescribeTransitGatewaysResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTransitGatewaysResult, XmlParseError> {
deserialize_elements::<_, DescribeTransitGatewaysResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"transitGatewaySet" => {
obj.transit_gateways.get_or_insert(vec![]).extend(
TransitGatewayListDeserializer::deserialize(
"transitGatewaySet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumeAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub volume_id: String,
}
struct DescribeVolumeAttributeRequestSerializer;
impl DescribeVolumeAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVolumeAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumeAttributeResult {
pub auto_enable_io: Option<AttributeBooleanValue>,
pub product_codes: Option<Vec<ProductCode>>,
pub volume_id: Option<String>,
}
struct DescribeVolumeAttributeResultDeserializer;
impl DescribeVolumeAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVolumeAttributeResult, XmlParseError> {
deserialize_elements::<_, DescribeVolumeAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"autoEnableIO" => {
obj.auto_enable_io = Some(AttributeBooleanValueDeserializer::deserialize(
"autoEnableIO",
stack,
)?);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumeStatusRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub volume_ids: Option<Vec<String>>,
}
struct DescribeVolumeStatusRequestSerializer;
impl DescribeVolumeStatusRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVolumeStatusRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.volume_ids {
VolumeIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VolumeId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumeStatusResult {
pub next_token: Option<String>,
pub volume_statuses: Option<Vec<VolumeStatusItem>>,
}
struct DescribeVolumeStatusResultDeserializer;
impl DescribeVolumeStatusResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVolumeStatusResult, XmlParseError> {
deserialize_elements::<_, DescribeVolumeStatusResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"volumeStatusSet" => {
obj.volume_statuses.get_or_insert(vec![]).extend(
VolumeStatusListDeserializer::deserialize("volumeStatusSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumesModificationsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub volume_ids: Option<Vec<String>>,
}
struct DescribeVolumesModificationsRequestSerializer;
impl DescribeVolumesModificationsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVolumesModificationsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.volume_ids {
VolumeIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VolumeId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumesModificationsResult {
pub next_token: Option<String>,
pub volumes_modifications: Option<Vec<VolumeModification>>,
}
struct DescribeVolumesModificationsResultDeserializer;
impl DescribeVolumesModificationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVolumesModificationsResult, XmlParseError> {
deserialize_elements::<_, DescribeVolumesModificationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"volumeModificationSet" => {
obj.volumes_modifications.get_or_insert(vec![]).extend(
VolumeModificationListDeserializer::deserialize(
"volumeModificationSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub volume_ids: Option<Vec<String>>,
}
struct DescribeVolumesRequestSerializer;
impl DescribeVolumesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVolumesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.volume_ids {
VolumeIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VolumeId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVolumesResult {
pub next_token: Option<String>,
pub volumes: Option<Vec<Volume>>,
}
struct DescribeVolumesResultDeserializer;
impl DescribeVolumesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVolumesResult, XmlParseError> {
deserialize_elements::<_, DescribeVolumesResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"volumeSet" => {
obj.volumes
.get_or_insert(vec![])
.extend(VolumeListDeserializer::deserialize("volumeSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct DescribeVpcAttributeRequestSerializer;
impl DescribeVpcAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcAttributeResult {
pub enable_dns_hostnames: Option<AttributeBooleanValue>,
pub enable_dns_support: Option<AttributeBooleanValue>,
pub vpc_id: Option<String>,
}
struct DescribeVpcAttributeResultDeserializer;
impl DescribeVpcAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcAttributeResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"enableDnsHostnames" => {
obj.enable_dns_hostnames =
Some(AttributeBooleanValueDeserializer::deserialize(
"enableDnsHostnames",
stack,
)?);
}
"enableDnsSupport" => {
obj.enable_dns_support =
Some(AttributeBooleanValueDeserializer::deserialize(
"enableDnsSupport",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcClassicLinkDnsSupportRequest {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub vpc_ids: Option<Vec<String>>,
}
struct DescribeVpcClassicLinkDnsSupportRequestSerializer;
impl DescribeVpcClassicLinkDnsSupportRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcClassicLinkDnsSupportRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.vpc_ids {
VpcClassicLinkIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcClassicLinkDnsSupportResult {
pub next_token: Option<String>,
pub vpcs: Option<Vec<ClassicLinkDnsSupport>>,
}
struct DescribeVpcClassicLinkDnsSupportResultDeserializer;
impl DescribeVpcClassicLinkDnsSupportResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcClassicLinkDnsSupportResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcClassicLinkDnsSupportResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("nextToken", stack)?);
}
"vpcs" => {
obj.vpcs.get_or_insert(vec![]).extend(
ClassicLinkDnsSupportListDeserializer::deserialize("vpcs", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcClassicLinkRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub vpc_ids: Option<Vec<String>>,
}
struct DescribeVpcClassicLinkRequestSerializer;
impl DescribeVpcClassicLinkRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcClassicLinkRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.vpc_ids {
VpcClassicLinkIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcClassicLinkResult {
pub vpcs: Option<Vec<VpcClassicLink>>,
}
struct DescribeVpcClassicLinkResultDeserializer;
impl DescribeVpcClassicLinkResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcClassicLinkResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcClassicLinkResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpcSet" => {
obj.vpcs.get_or_insert(vec![]).extend(
VpcClassicLinkListDeserializer::deserialize("vpcSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointConnectionNotificationsRequest {
pub connection_notification_id: Option<String>,
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeVpcEndpointConnectionNotificationsRequestSerializer;
impl DescribeVpcEndpointConnectionNotificationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeVpcEndpointConnectionNotificationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.connection_notification_id {
params.put(
&format!("{}{}", prefix, "ConnectionNotificationId"),
&field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointConnectionNotificationsResult {
pub connection_notification_set: Option<Vec<ConnectionNotification>>,
pub next_token: Option<String>,
}
struct DescribeVpcEndpointConnectionNotificationsResultDeserializer;
impl DescribeVpcEndpointConnectionNotificationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcEndpointConnectionNotificationsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcEndpointConnectionNotificationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"connectionNotificationSet" => {
obj.connection_notification_set
.get_or_insert(vec![])
.extend(ConnectionNotificationSetDeserializer::deserialize(
"connectionNotificationSet",
stack,
)?);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointConnectionsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeVpcEndpointConnectionsRequestSerializer;
impl DescribeVpcEndpointConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcEndpointConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointConnectionsResult {
pub next_token: Option<String>,
pub vpc_endpoint_connections: Option<Vec<VpcEndpointConnection>>,
}
struct DescribeVpcEndpointConnectionsResultDeserializer;
impl DescribeVpcEndpointConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcEndpointConnectionsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcEndpointConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"vpcEndpointConnectionSet" => {
obj.vpc_endpoint_connections.get_or_insert(vec![]).extend(
VpcEndpointConnectionSetDeserializer::deserialize(
"vpcEndpointConnectionSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointServiceConfigurationsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub service_ids: Option<Vec<String>>,
}
struct DescribeVpcEndpointServiceConfigurationsRequestSerializer;
impl DescribeVpcEndpointServiceConfigurationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeVpcEndpointServiceConfigurationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.service_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ServiceId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointServiceConfigurationsResult {
pub next_token: Option<String>,
pub service_configurations: Option<Vec<ServiceConfiguration>>,
}
struct DescribeVpcEndpointServiceConfigurationsResultDeserializer;
impl DescribeVpcEndpointServiceConfigurationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcEndpointServiceConfigurationsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcEndpointServiceConfigurationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"serviceConfigurationSet" => {
obj.service_configurations.get_or_insert(vec![]).extend(
ServiceConfigurationSetDeserializer::deserialize(
"serviceConfigurationSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointServicePermissionsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub service_id: String,
}
struct DescribeVpcEndpointServicePermissionsRequestSerializer;
impl DescribeVpcEndpointServicePermissionsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeVpcEndpointServicePermissionsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "ServiceId"), &obj.service_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointServicePermissionsResult {
pub allowed_principals: Option<Vec<AllowedPrincipal>>,
pub next_token: Option<String>,
}
struct DescribeVpcEndpointServicePermissionsResultDeserializer;
impl DescribeVpcEndpointServicePermissionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcEndpointServicePermissionsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcEndpointServicePermissionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"allowedPrincipals" => {
obj.allowed_principals.get_or_insert(vec![]).extend(
AllowedPrincipalSetDeserializer::deserialize(
"allowedPrincipals",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointServicesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub service_names: Option<Vec<String>>,
}
struct DescribeVpcEndpointServicesRequestSerializer;
impl DescribeVpcEndpointServicesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcEndpointServicesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.service_names {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ServiceName"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointServicesResult {
pub next_token: Option<String>,
pub service_details: Option<Vec<ServiceDetail>>,
pub service_names: Option<Vec<String>>,
}
struct DescribeVpcEndpointServicesResultDeserializer;
impl DescribeVpcEndpointServicesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcEndpointServicesResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcEndpointServicesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"serviceDetailSet" => {
obj.service_details.get_or_insert(vec![]).extend(
ServiceDetailSetDeserializer::deserialize("serviceDetailSet", stack)?,
);
}
"serviceNameSet" => {
obj.service_names.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("serviceNameSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub vpc_endpoint_ids: Option<Vec<String>>,
}
struct DescribeVpcEndpointsRequestSerializer;
impl DescribeVpcEndpointsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcEndpointsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.vpc_endpoint_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcEndpointId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcEndpointsResult {
pub next_token: Option<String>,
pub vpc_endpoints: Option<Vec<VpcEndpoint>>,
}
struct DescribeVpcEndpointsResultDeserializer;
impl DescribeVpcEndpointsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcEndpointsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcEndpointsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"vpcEndpointSet" => {
obj.vpc_endpoints.get_or_insert(vec![]).extend(
VpcEndpointSetDeserializer::deserialize("vpcEndpointSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcPeeringConnectionsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub vpc_peering_connection_ids: Option<Vec<String>>,
}
struct DescribeVpcPeeringConnectionsRequestSerializer;
impl DescribeVpcPeeringConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcPeeringConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.vpc_peering_connection_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcPeeringConnectionsResult {
pub next_token: Option<String>,
pub vpc_peering_connections: Option<Vec<VpcPeeringConnection>>,
}
struct DescribeVpcPeeringConnectionsResultDeserializer;
impl DescribeVpcPeeringConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcPeeringConnectionsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcPeeringConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"vpcPeeringConnectionSet" => {
obj.vpc_peering_connections.get_or_insert(vec![]).extend(
VpcPeeringConnectionListDeserializer::deserialize(
"vpcPeeringConnectionSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub vpc_ids: Option<Vec<String>>,
}
struct DescribeVpcsRequestSerializer;
impl DescribeVpcsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpcsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.vpc_ids {
VpcIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpcsResult {
pub next_token: Option<String>,
pub vpcs: Option<Vec<Vpc>>,
}
struct DescribeVpcsResultDeserializer;
impl DescribeVpcsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpcsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpcsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"vpcSet" => {
obj.vpcs
.get_or_insert(vec![])
.extend(VpcListDeserializer::deserialize("vpcSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpnConnectionsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub vpn_connection_ids: Option<Vec<String>>,
}
struct DescribeVpnConnectionsRequestSerializer;
impl DescribeVpnConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpnConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.vpn_connection_ids {
VpnConnectionIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpnConnectionId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpnConnectionsResult {
pub vpn_connections: Option<Vec<VpnConnection>>,
}
struct DescribeVpnConnectionsResultDeserializer;
impl DescribeVpnConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpnConnectionsResult, XmlParseError> {
deserialize_elements::<_, DescribeVpnConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpnConnectionSet" => {
obj.vpn_connections.get_or_insert(vec![]).extend(
VpnConnectionListDeserializer::deserialize("vpnConnectionSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpnGatewaysRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub vpn_gateway_ids: Option<Vec<String>>,
}
struct DescribeVpnGatewaysRequestSerializer;
impl DescribeVpnGatewaysRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeVpnGatewaysRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.vpn_gateway_ids {
VpnGatewayIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpnGatewayId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeVpnGatewaysResult {
pub vpn_gateways: Option<Vec<VpnGateway>>,
}
struct DescribeVpnGatewaysResultDeserializer;
impl DescribeVpnGatewaysResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeVpnGatewaysResult, XmlParseError> {
deserialize_elements::<_, DescribeVpnGatewaysResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpnGatewaySet" => {
obj.vpn_gateways.get_or_insert(vec![]).extend(
VpnGatewayListDeserializer::deserialize("vpnGatewaySet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachClassicLinkVpcRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
pub vpc_id: String,
}
struct DetachClassicLinkVpcRequestSerializer;
impl DetachClassicLinkVpcRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachClassicLinkVpcRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachClassicLinkVpcResult {
pub return_: Option<bool>,
}
struct DetachClassicLinkVpcResultDeserializer;
impl DetachClassicLinkVpcResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetachClassicLinkVpcResult, XmlParseError> {
deserialize_elements::<_, DetachClassicLinkVpcResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachInternetGatewayRequest {
pub dry_run: Option<bool>,
pub internet_gateway_id: String,
pub vpc_id: String,
}
struct DetachInternetGatewayRequestSerializer;
impl DetachInternetGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachInternetGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InternetGatewayId"),
&obj.internet_gateway_id,
);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachNetworkInterfaceRequest {
pub attachment_id: String,
pub dry_run: Option<bool>,
pub force: Option<bool>,
}
struct DetachNetworkInterfaceRequestSerializer;
impl DetachNetworkInterfaceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachNetworkInterfaceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "AttachmentId"), &obj.attachment_id);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachVolumeRequest {
pub device: Option<String>,
pub dry_run: Option<bool>,
pub force: Option<bool>,
pub instance_id: Option<String>,
pub volume_id: String,
}
struct DetachVolumeRequestSerializer;
impl DetachVolumeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachVolumeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.device {
params.put(&format!("{}{}", prefix, "Device"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachVpnGatewayRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
pub vpn_gateway_id: String,
}
struct DetachVpnGatewayRequestSerializer;
impl DetachVpnGatewayRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachVpnGatewayRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
params.put(
&format!("{}{}", prefix, "VpnGatewayId"),
&obj.vpn_gateway_id,
);
}
}
struct DeviceTypeDeserializer;
impl DeviceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DhcpConfiguration {
pub key: Option<String>,
pub values: Option<Vec<AttributeValue>>,
}
struct DhcpConfigurationDeserializer;
impl DhcpConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DhcpConfiguration, XmlParseError> {
deserialize_elements::<_, DhcpConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"key" => {
obj.key = Some(StringDeserializer::deserialize("key", stack)?);
}
"valueSet" => {
obj.values.get_or_insert(vec![]).extend(
DhcpConfigurationValueListDeserializer::deserialize("valueSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DhcpConfigurationListDeserializer;
impl DhcpConfigurationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DhcpConfiguration>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DhcpConfigurationDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct DhcpConfigurationValueListDeserializer;
impl DhcpConfigurationValueListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AttributeValue>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(AttributeValueDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DhcpOptions {
pub dhcp_configurations: Option<Vec<DhcpConfiguration>>,
pub dhcp_options_id: Option<String>,
pub owner_id: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct DhcpOptionsDeserializer;
impl DhcpOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DhcpOptions, XmlParseError> {
deserialize_elements::<_, DhcpOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"dhcpConfigurationSet" => {
obj.dhcp_configurations.get_or_insert(vec![]).extend(
DhcpConfigurationListDeserializer::deserialize(
"dhcpConfigurationSet",
stack,
)?,
);
}
"dhcpOptionsId" => {
obj.dhcp_options_id =
Some(StringDeserializer::deserialize("dhcpOptionsId", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DhcpOptionsIdStringListSerializer;
impl DhcpOptionsIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct DhcpOptionsListDeserializer;
impl DhcpOptionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DhcpOptions>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DhcpOptionsDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DirectoryServiceAuthentication {
pub directory_id: Option<String>,
}
struct DirectoryServiceAuthenticationDeserializer;
impl DirectoryServiceAuthenticationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DirectoryServiceAuthentication, XmlParseError> {
deserialize_elements::<_, DirectoryServiceAuthentication, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"directoryId" => {
obj.directory_id =
Some(StringDeserializer::deserialize("directoryId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DirectoryServiceAuthenticationRequest {
pub directory_id: Option<String>,
}
struct DirectoryServiceAuthenticationRequestSerializer;
impl DirectoryServiceAuthenticationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DirectoryServiceAuthenticationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.directory_id {
params.put(&format!("{}{}", prefix, "DirectoryId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableEbsEncryptionByDefaultRequest {
pub dry_run: Option<bool>,
}
struct DisableEbsEncryptionByDefaultRequestSerializer;
impl DisableEbsEncryptionByDefaultRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableEbsEncryptionByDefaultRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableEbsEncryptionByDefaultResult {
pub ebs_encryption_by_default: Option<bool>,
}
struct DisableEbsEncryptionByDefaultResultDeserializer;
impl DisableEbsEncryptionByDefaultResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableEbsEncryptionByDefaultResult, XmlParseError> {
deserialize_elements::<_, DisableEbsEncryptionByDefaultResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ebsEncryptionByDefault" => {
obj.ebs_encryption_by_default = Some(BooleanDeserializer::deserialize(
"ebsEncryptionByDefault",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableTransitGatewayRouteTablePropagationRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
pub transit_gateway_route_table_id: String,
}
struct DisableTransitGatewayRouteTablePropagationRequestSerializer;
impl DisableTransitGatewayRouteTablePropagationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DisableTransitGatewayRouteTablePropagationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableTransitGatewayRouteTablePropagationResult {
pub propagation: Option<TransitGatewayPropagation>,
}
struct DisableTransitGatewayRouteTablePropagationResultDeserializer;
impl DisableTransitGatewayRouteTablePropagationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableTransitGatewayRouteTablePropagationResult, XmlParseError> {
deserialize_elements::<_, DisableTransitGatewayRouteTablePropagationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"propagation" => {
obj.propagation = Some(TransitGatewayPropagationDeserializer::deserialize(
"propagation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableVgwRoutePropagationRequest {
pub gateway_id: String,
pub route_table_id: String,
}
struct DisableVgwRoutePropagationRequestSerializer;
impl DisableVgwRoutePropagationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableVgwRoutePropagationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "GatewayId"), &obj.gateway_id);
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableVpcClassicLinkDnsSupportRequest {
pub vpc_id: Option<String>,
}
struct DisableVpcClassicLinkDnsSupportRequestSerializer;
impl DisableVpcClassicLinkDnsSupportRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableVpcClassicLinkDnsSupportRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.vpc_id {
params.put(&format!("{}{}", prefix, "VpcId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableVpcClassicLinkDnsSupportResult {
pub return_: Option<bool>,
}
struct DisableVpcClassicLinkDnsSupportResultDeserializer;
impl DisableVpcClassicLinkDnsSupportResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableVpcClassicLinkDnsSupportResult, XmlParseError> {
deserialize_elements::<_, DisableVpcClassicLinkDnsSupportResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableVpcClassicLinkRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct DisableVpcClassicLinkRequestSerializer;
impl DisableVpcClassicLinkRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableVpcClassicLinkRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableVpcClassicLinkResult {
pub return_: Option<bool>,
}
struct DisableVpcClassicLinkResultDeserializer;
impl DisableVpcClassicLinkResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableVpcClassicLinkResult, XmlParseError> {
deserialize_elements::<_, DisableVpcClassicLinkResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateAddressRequest {
pub association_id: Option<String>,
pub dry_run: Option<bool>,
pub public_ip: Option<String>,
}
struct DisassociateAddressRequestSerializer;
impl DisassociateAddressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateAddressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.association_id {
params.put(&format!("{}{}", prefix, "AssociationId"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.public_ip {
params.put(&format!("{}{}", prefix, "PublicIp"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateClientVpnTargetNetworkRequest {
pub association_id: String,
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
}
struct DisassociateClientVpnTargetNetworkRequestSerializer;
impl DisassociateClientVpnTargetNetworkRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateClientVpnTargetNetworkRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateClientVpnTargetNetworkResult {
pub association_id: Option<String>,
pub status: Option<AssociationStatus>,
}
struct DisassociateClientVpnTargetNetworkResultDeserializer;
impl DisassociateClientVpnTargetNetworkResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateClientVpnTargetNetworkResult, XmlParseError> {
deserialize_elements::<_, DisassociateClientVpnTargetNetworkResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"status" => {
obj.status =
Some(AssociationStatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateIamInstanceProfileRequest {
pub association_id: String,
}
struct DisassociateIamInstanceProfileRequestSerializer;
impl DisassociateIamInstanceProfileRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateIamInstanceProfileRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateIamInstanceProfileResult {
pub iam_instance_profile_association: Option<IamInstanceProfileAssociation>,
}
struct DisassociateIamInstanceProfileResultDeserializer;
impl DisassociateIamInstanceProfileResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateIamInstanceProfileResult, XmlParseError> {
deserialize_elements::<_, DisassociateIamInstanceProfileResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"iamInstanceProfileAssociation" => {
obj.iam_instance_profile_association =
Some(IamInstanceProfileAssociationDeserializer::deserialize(
"iamInstanceProfileAssociation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateRouteTableRequest {
pub association_id: String,
pub dry_run: Option<bool>,
}
struct DisassociateRouteTableRequestSerializer;
impl DisassociateRouteTableRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateRouteTableRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateSubnetCidrBlockRequest {
pub association_id: String,
}
struct DisassociateSubnetCidrBlockRequestSerializer;
impl DisassociateSubnetCidrBlockRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateSubnetCidrBlockRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateSubnetCidrBlockResult {
pub ipv_6_cidr_block_association: Option<SubnetIpv6CidrBlockAssociation>,
pub subnet_id: Option<String>,
}
struct DisassociateSubnetCidrBlockResultDeserializer;
impl DisassociateSubnetCidrBlockResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateSubnetCidrBlockResult, XmlParseError> {
deserialize_elements::<_, DisassociateSubnetCidrBlockResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ipv6CidrBlockAssociation" => {
obj.ipv_6_cidr_block_association =
Some(SubnetIpv6CidrBlockAssociationDeserializer::deserialize(
"ipv6CidrBlockAssociation",
stack,
)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateTransitGatewayRouteTableRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
pub transit_gateway_route_table_id: String,
}
struct DisassociateTransitGatewayRouteTableRequestSerializer;
impl DisassociateTransitGatewayRouteTableRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DisassociateTransitGatewayRouteTableRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateTransitGatewayRouteTableResult {
pub association: Option<TransitGatewayAssociation>,
}
struct DisassociateTransitGatewayRouteTableResultDeserializer;
impl DisassociateTransitGatewayRouteTableResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateTransitGatewayRouteTableResult, XmlParseError> {
deserialize_elements::<_, DisassociateTransitGatewayRouteTableResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"association" => {
obj.association = Some(TransitGatewayAssociationDeserializer::deserialize(
"association",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateVpcCidrBlockRequest {
pub association_id: String,
}
struct DisassociateVpcCidrBlockRequestSerializer;
impl DisassociateVpcCidrBlockRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateVpcCidrBlockRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateVpcCidrBlockResult {
pub cidr_block_association: Option<VpcCidrBlockAssociation>,
pub ipv_6_cidr_block_association: Option<VpcIpv6CidrBlockAssociation>,
pub vpc_id: Option<String>,
}
struct DisassociateVpcCidrBlockResultDeserializer;
impl DisassociateVpcCidrBlockResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateVpcCidrBlockResult, XmlParseError> {
deserialize_elements::<_, DisassociateVpcCidrBlockResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"cidrBlockAssociation" => {
obj.cidr_block_association =
Some(VpcCidrBlockAssociationDeserializer::deserialize(
"cidrBlockAssociation",
stack,
)?);
}
"ipv6CidrBlockAssociation" => {
obj.ipv_6_cidr_block_association =
Some(VpcIpv6CidrBlockAssociationDeserializer::deserialize(
"ipv6CidrBlockAssociation",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DiskImage {
pub description: Option<String>,
pub image: Option<DiskImageDetail>,
pub volume: Option<VolumeDetail>,
}
struct DiskImageSerializer;
impl DiskImageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DiskImage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.image {
DiskImageDetailSerializer::serialize(
params,
&format!("{}{}", prefix, "Image"),
field_value,
);
}
if let Some(ref field_value) = obj.volume {
VolumeDetailSerializer::serialize(
params,
&format!("{}{}", prefix, "Volume"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DiskImageDescription {
pub checksum: Option<String>,
pub format: Option<String>,
pub import_manifest_url: Option<String>,
pub size: Option<i64>,
}
struct DiskImageDescriptionDeserializer;
impl DiskImageDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DiskImageDescription, XmlParseError> {
deserialize_elements::<_, DiskImageDescription, _>(tag_name, stack, |name, stack, obj| {
match name {
"checksum" => {
obj.checksum = Some(StringDeserializer::deserialize("checksum", stack)?);
}
"format" => {
obj.format = Some(DiskImageFormatDeserializer::deserialize("format", stack)?);
}
"importManifestUrl" => {
obj.import_manifest_url =
Some(StringDeserializer::deserialize("importManifestUrl", stack)?);
}
"size" => {
obj.size = Some(LongDeserializer::deserialize("size", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DiskImageDetail {
pub bytes: i64,
pub format: String,
pub import_manifest_url: String,
}
struct DiskImageDetailSerializer;
impl DiskImageDetailSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DiskImageDetail) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Bytes"), &obj.bytes);
params.put(&format!("{}{}", prefix, "Format"), &obj.format);
params.put(
&format!("{}{}", prefix, "ImportManifestUrl"),
&obj.import_manifest_url,
);
}
}
struct DiskImageFormatDeserializer;
impl DiskImageFormatDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DiskImageListSerializer;
impl DiskImageListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<DiskImage>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
DiskImageSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DiskImageVolumeDescription {
pub id: Option<String>,
pub size: Option<i64>,
}
struct DiskImageVolumeDescriptionDeserializer;
impl DiskImageVolumeDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DiskImageVolumeDescription, XmlParseError> {
deserialize_elements::<_, DiskImageVolumeDescription, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"id" => {
obj.id = Some(StringDeserializer::deserialize("id", stack)?);
}
"size" => {
obj.size = Some(LongDeserializer::deserialize("size", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DnsEntry {
pub dns_name: Option<String>,
pub hosted_zone_id: Option<String>,
}
struct DnsEntryDeserializer;
impl DnsEntryDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DnsEntry, XmlParseError> {
deserialize_elements::<_, DnsEntry, _>(tag_name, stack, |name, stack, obj| {
match name {
"dnsName" => {
obj.dns_name = Some(StringDeserializer::deserialize("dnsName", stack)?);
}
"hostedZoneId" => {
obj.hosted_zone_id =
Some(StringDeserializer::deserialize("hostedZoneId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DnsEntrySetDeserializer;
impl DnsEntrySetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DnsEntry>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(DnsEntryDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DnsServersOptionsModifyStructure {
pub custom_dns_servers: Option<Vec<String>>,
pub enabled: Option<bool>,
}
struct DnsServersOptionsModifyStructureSerializer;
impl DnsServersOptionsModifyStructureSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DnsServersOptionsModifyStructure) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.custom_dns_servers {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "CustomDnsServers"),
field_value,
);
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
}
}
struct DnsSupportValueDeserializer;
impl DnsSupportValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DomainTypeDeserializer;
impl DomainTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DoubleDeserializer;
impl DoubleDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = f64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EbsBlockDevice {
pub delete_on_termination: Option<bool>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub snapshot_id: Option<String>,
pub volume_size: Option<i64>,
pub volume_type: Option<String>,
}
struct EbsBlockDeviceDeserializer;
impl EbsBlockDeviceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EbsBlockDevice, XmlParseError> {
deserialize_elements::<_, EbsBlockDevice, _>(tag_name, stack, |name, stack, obj| {
match name {
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"iops" => {
obj.iops = Some(IntegerDeserializer::deserialize("iops", stack)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"volumeSize" => {
obj.volume_size = Some(IntegerDeserializer::deserialize("volumeSize", stack)?);
}
"volumeType" => {
obj.volume_type =
Some(VolumeTypeDeserializer::deserialize("volumeType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct EbsBlockDeviceSerializer;
impl EbsBlockDeviceSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EbsBlockDevice) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_id {
params.put(&format!("{}{}", prefix, "SnapshotId"), &field_value);
}
if let Some(ref field_value) = obj.volume_size {
params.put(&format!("{}{}", prefix, "VolumeSize"), &field_value);
}
if let Some(ref field_value) = obj.volume_type {
params.put(&format!("{}{}", prefix, "VolumeType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EbsInstanceBlockDevice {
pub attach_time: Option<String>,
pub delete_on_termination: Option<bool>,
pub status: Option<String>,
pub volume_id: Option<String>,
}
struct EbsInstanceBlockDeviceDeserializer;
impl EbsInstanceBlockDeviceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EbsInstanceBlockDevice, XmlParseError> {
deserialize_elements::<_, EbsInstanceBlockDevice, _>(tag_name, stack, |name, stack, obj| {
match name {
"attachTime" => {
obj.attach_time = Some(DateTimeDeserializer::deserialize("attachTime", stack)?);
}
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"status" => {
obj.status = Some(AttachmentStatusDeserializer::deserialize("status", stack)?);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EbsInstanceBlockDeviceSpecification {
pub delete_on_termination: Option<bool>,
pub volume_id: Option<String>,
}
struct EbsInstanceBlockDeviceSpecificationSerializer;
impl EbsInstanceBlockDeviceSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EbsInstanceBlockDeviceSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.volume_id {
params.put(&format!("{}{}", prefix, "VolumeId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EgressOnlyInternetGateway {
pub attachments: Option<Vec<InternetGatewayAttachment>>,
pub egress_only_internet_gateway_id: Option<String>,
}
struct EgressOnlyInternetGatewayDeserializer;
impl EgressOnlyInternetGatewayDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EgressOnlyInternetGateway, XmlParseError> {
deserialize_elements::<_, EgressOnlyInternetGateway, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"attachmentSet" => {
obj.attachments.get_or_insert(vec![]).extend(
InternetGatewayAttachmentListDeserializer::deserialize(
"attachmentSet",
stack,
)?,
);
}
"egressOnlyInternetGatewayId" => {
obj.egress_only_internet_gateway_id =
Some(EgressOnlyInternetGatewayIdDeserializer::deserialize(
"egressOnlyInternetGatewayId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct EgressOnlyInternetGatewayIdDeserializer;
impl EgressOnlyInternetGatewayIdDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct EgressOnlyInternetGatewayIdListSerializer;
impl EgressOnlyInternetGatewayIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct EgressOnlyInternetGatewayListDeserializer;
impl EgressOnlyInternetGatewayListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EgressOnlyInternetGateway>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(EgressOnlyInternetGatewayDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticGpuAssociation {
pub elastic_gpu_association_id: Option<String>,
pub elastic_gpu_association_state: Option<String>,
pub elastic_gpu_association_time: Option<String>,
pub elastic_gpu_id: Option<String>,
}
struct ElasticGpuAssociationDeserializer;
impl ElasticGpuAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticGpuAssociation, XmlParseError> {
deserialize_elements::<_, ElasticGpuAssociation, _>(tag_name, stack, |name, stack, obj| {
match name {
"elasticGpuAssociationId" => {
obj.elastic_gpu_association_id = Some(StringDeserializer::deserialize(
"elasticGpuAssociationId",
stack,
)?);
}
"elasticGpuAssociationState" => {
obj.elastic_gpu_association_state = Some(StringDeserializer::deserialize(
"elasticGpuAssociationState",
stack,
)?);
}
"elasticGpuAssociationTime" => {
obj.elastic_gpu_association_time = Some(StringDeserializer::deserialize(
"elasticGpuAssociationTime",
stack,
)?);
}
"elasticGpuId" => {
obj.elastic_gpu_id =
Some(StringDeserializer::deserialize("elasticGpuId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ElasticGpuAssociationListDeserializer;
impl ElasticGpuAssociationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ElasticGpuAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ElasticGpuAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticGpuHealth {
pub status: Option<String>,
}
struct ElasticGpuHealthDeserializer;
impl ElasticGpuHealthDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticGpuHealth, XmlParseError> {
deserialize_elements::<_, ElasticGpuHealth, _>(tag_name, stack, |name, stack, obj| {
match name {
"status" => {
obj.status = Some(ElasticGpuStatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ElasticGpuIdSetSerializer;
impl ElasticGpuIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ElasticGpuSetDeserializer;
impl ElasticGpuSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ElasticGpus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ElasticGpusDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticGpuSpecification {
pub type_: String,
}
struct ElasticGpuSpecificationSerializer;
impl ElasticGpuSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ElasticGpuSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
}
}
struct ElasticGpuSpecificationListSerializer;
impl ElasticGpuSpecificationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ElasticGpuSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ElasticGpuSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticGpuSpecificationResponse {
pub type_: Option<String>,
}
struct ElasticGpuSpecificationResponseDeserializer;
impl ElasticGpuSpecificationResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticGpuSpecificationResponse, XmlParseError> {
deserialize_elements::<_, ElasticGpuSpecificationResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"type" => {
obj.type_ = Some(StringDeserializer::deserialize("type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ElasticGpuSpecificationResponseListDeserializer;
impl ElasticGpuSpecificationResponseListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ElasticGpuSpecificationResponse>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ElasticGpuSpecificationResponseDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ElasticGpuSpecificationsSerializer;
impl ElasticGpuSpecificationsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ElasticGpuSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ElasticGpuSpecificationSerializer::serialize(params, &key, obj);
}
}
}
struct ElasticGpuStateDeserializer;
impl ElasticGpuStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ElasticGpuStatusDeserializer;
impl ElasticGpuStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticGpus {
pub availability_zone: Option<String>,
pub elastic_gpu_health: Option<ElasticGpuHealth>,
pub elastic_gpu_id: Option<String>,
pub elastic_gpu_state: Option<String>,
pub elastic_gpu_type: Option<String>,
pub instance_id: Option<String>,
}
struct ElasticGpusDeserializer;
impl ElasticGpusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticGpus, XmlParseError> {
deserialize_elements::<_, ElasticGpus, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"elasticGpuHealth" => {
obj.elastic_gpu_health = Some(ElasticGpuHealthDeserializer::deserialize(
"elasticGpuHealth",
stack,
)?);
}
"elasticGpuId" => {
obj.elastic_gpu_id =
Some(StringDeserializer::deserialize("elasticGpuId", stack)?);
}
"elasticGpuState" => {
obj.elastic_gpu_state = Some(ElasticGpuStateDeserializer::deserialize(
"elasticGpuState",
stack,
)?);
}
"elasticGpuType" => {
obj.elastic_gpu_type =
Some(StringDeserializer::deserialize("elasticGpuType", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticInferenceAccelerator {
pub type_: String,
}
struct ElasticInferenceAcceleratorSerializer;
impl ElasticInferenceAcceleratorSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ElasticInferenceAccelerator) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticInferenceAcceleratorAssociation {
pub elastic_inference_accelerator_arn: Option<String>,
pub elastic_inference_accelerator_association_id: Option<String>,
pub elastic_inference_accelerator_association_state: Option<String>,
pub elastic_inference_accelerator_association_time: Option<String>,
}
struct ElasticInferenceAcceleratorAssociationDeserializer;
impl ElasticInferenceAcceleratorAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticInferenceAcceleratorAssociation, XmlParseError> {
deserialize_elements::<_, ElasticInferenceAcceleratorAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"elasticInferenceAcceleratorArn" => {
obj.elastic_inference_accelerator_arn =
Some(StringDeserializer::deserialize(
"elasticInferenceAcceleratorArn",
stack,
)?);
}
"elasticInferenceAcceleratorAssociationId" => {
obj.elastic_inference_accelerator_association_id =
Some(StringDeserializer::deserialize(
"elasticInferenceAcceleratorAssociationId",
stack,
)?);
}
"elasticInferenceAcceleratorAssociationState" => {
obj.elastic_inference_accelerator_association_state =
Some(StringDeserializer::deserialize(
"elasticInferenceAcceleratorAssociationState",
stack,
)?);
}
"elasticInferenceAcceleratorAssociationTime" => {
obj.elastic_inference_accelerator_association_time =
Some(DateTimeDeserializer::deserialize(
"elasticInferenceAcceleratorAssociationTime",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ElasticInferenceAcceleratorAssociationListDeserializer;
impl ElasticInferenceAcceleratorAssociationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ElasticInferenceAcceleratorAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
ElasticInferenceAcceleratorAssociationDeserializer::deserialize("item", stack)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ElasticInferenceAcceleratorsSerializer;
impl ElasticInferenceAcceleratorsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ElasticInferenceAccelerator>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ElasticInferenceAcceleratorSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableEbsEncryptionByDefaultRequest {
pub dry_run: Option<bool>,
}
struct EnableEbsEncryptionByDefaultRequestSerializer;
impl EnableEbsEncryptionByDefaultRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableEbsEncryptionByDefaultRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableEbsEncryptionByDefaultResult {
pub ebs_encryption_by_default: Option<bool>,
}
struct EnableEbsEncryptionByDefaultResultDeserializer;
impl EnableEbsEncryptionByDefaultResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableEbsEncryptionByDefaultResult, XmlParseError> {
deserialize_elements::<_, EnableEbsEncryptionByDefaultResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ebsEncryptionByDefault" => {
obj.ebs_encryption_by_default = Some(BooleanDeserializer::deserialize(
"ebsEncryptionByDefault",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableTransitGatewayRouteTablePropagationRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
pub transit_gateway_route_table_id: String,
}
struct EnableTransitGatewayRouteTablePropagationRequestSerializer;
impl EnableTransitGatewayRouteTablePropagationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &EnableTransitGatewayRouteTablePropagationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableTransitGatewayRouteTablePropagationResult {
pub propagation: Option<TransitGatewayPropagation>,
}
struct EnableTransitGatewayRouteTablePropagationResultDeserializer;
impl EnableTransitGatewayRouteTablePropagationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableTransitGatewayRouteTablePropagationResult, XmlParseError> {
deserialize_elements::<_, EnableTransitGatewayRouteTablePropagationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"propagation" => {
obj.propagation = Some(TransitGatewayPropagationDeserializer::deserialize(
"propagation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableVgwRoutePropagationRequest {
pub gateway_id: String,
pub route_table_id: String,
}
struct EnableVgwRoutePropagationRequestSerializer;
impl EnableVgwRoutePropagationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableVgwRoutePropagationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "GatewayId"), &obj.gateway_id);
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableVolumeIORequest {
pub dry_run: Option<bool>,
pub volume_id: String,
}
struct EnableVolumeIORequestSerializer;
impl EnableVolumeIORequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableVolumeIORequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableVpcClassicLinkDnsSupportRequest {
pub vpc_id: Option<String>,
}
struct EnableVpcClassicLinkDnsSupportRequestSerializer;
impl EnableVpcClassicLinkDnsSupportRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableVpcClassicLinkDnsSupportRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.vpc_id {
params.put(&format!("{}{}", prefix, "VpcId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableVpcClassicLinkDnsSupportResult {
pub return_: Option<bool>,
}
struct EnableVpcClassicLinkDnsSupportResultDeserializer;
impl EnableVpcClassicLinkDnsSupportResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableVpcClassicLinkDnsSupportResult, XmlParseError> {
deserialize_elements::<_, EnableVpcClassicLinkDnsSupportResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableVpcClassicLinkRequest {
pub dry_run: Option<bool>,
pub vpc_id: String,
}
struct EnableVpcClassicLinkRequestSerializer;
impl EnableVpcClassicLinkRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableVpcClassicLinkRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableVpcClassicLinkResult {
pub return_: Option<bool>,
}
struct EnableVpcClassicLinkResultDeserializer;
impl EnableVpcClassicLinkResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableVpcClassicLinkResult, XmlParseError> {
deserialize_elements::<_, EnableVpcClassicLinkResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct EndDateTypeDeserializer;
impl EndDateTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct EndpointSetDeserializer;
impl EndpointSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClientVpnEndpoint>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ClientVpnEndpointDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct EventCodeDeserializer;
impl EventCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EventInformation {
pub event_description: Option<String>,
pub event_sub_type: Option<String>,
pub instance_id: Option<String>,
}
struct EventInformationDeserializer;
impl EventInformationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventInformation, XmlParseError> {
deserialize_elements::<_, EventInformation, _>(tag_name, stack, |name, stack, obj| {
match name {
"eventDescription" => {
obj.event_description =
Some(StringDeserializer::deserialize("eventDescription", stack)?);
}
"eventSubType" => {
obj.event_sub_type =
Some(StringDeserializer::deserialize("eventSubType", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct EventTypeDeserializer;
impl EventTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ExcessCapacityTerminationPolicyDeserializer;
impl ExcessCapacityTerminationPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ExecutableByStringListSerializer;
impl ExecutableByStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportClientVpnClientCertificateRevocationListRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
}
struct ExportClientVpnClientCertificateRevocationListRequestSerializer;
impl ExportClientVpnClientCertificateRevocationListRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ExportClientVpnClientCertificateRevocationListRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportClientVpnClientCertificateRevocationListResult {
pub certificate_revocation_list: Option<String>,
pub status: Option<ClientCertificateRevocationListStatus>,
}
struct ExportClientVpnClientCertificateRevocationListResultDeserializer;
impl ExportClientVpnClientCertificateRevocationListResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExportClientVpnClientCertificateRevocationListResult, XmlParseError> {
deserialize_elements::<_, ExportClientVpnClientCertificateRevocationListResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"certificateRevocationList" => {
obj.certificate_revocation_list = Some(StringDeserializer::deserialize(
"certificateRevocationList",
stack,
)?);
}
"status" => {
obj.status = Some(
ClientCertificateRevocationListStatusDeserializer::deserialize(
"status", stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportClientVpnClientConfigurationRequest {
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
}
struct ExportClientVpnClientConfigurationRequestSerializer;
impl ExportClientVpnClientConfigurationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ExportClientVpnClientConfigurationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportClientVpnClientConfigurationResult {
pub client_configuration: Option<String>,
}
struct ExportClientVpnClientConfigurationResultDeserializer;
impl ExportClientVpnClientConfigurationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExportClientVpnClientConfigurationResult, XmlParseError> {
deserialize_elements::<_, ExportClientVpnClientConfigurationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientConfiguration" => {
obj.client_configuration = Some(StringDeserializer::deserialize(
"clientConfiguration",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ExportEnvironmentDeserializer;
impl ExportEnvironmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportTask {
pub description: Option<String>,
pub export_task_id: Option<String>,
pub export_to_s3_task: Option<ExportToS3Task>,
pub instance_export_details: Option<InstanceExportDetails>,
pub state: Option<String>,
pub status_message: Option<String>,
}
struct ExportTaskDeserializer;
impl ExportTaskDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExportTask, XmlParseError> {
deserialize_elements::<_, ExportTask, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"exportTaskId" => {
obj.export_task_id =
Some(StringDeserializer::deserialize("exportTaskId", stack)?);
}
"exportToS3" => {
obj.export_to_s3_task = Some(ExportToS3TaskDeserializer::deserialize(
"exportToS3",
stack,
)?);
}
"instanceExport" => {
obj.instance_export_details = Some(
InstanceExportDetailsDeserializer::deserialize("instanceExport", stack)?,
);
}
"state" => {
obj.state = Some(ExportTaskStateDeserializer::deserialize("state", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ExportTaskIdStringListSerializer;
impl ExportTaskIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ExportTaskListDeserializer;
impl ExportTaskListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ExportTask>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ExportTaskDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ExportTaskStateDeserializer;
impl ExportTaskStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportToS3Task {
pub container_format: Option<String>,
pub disk_image_format: Option<String>,
pub s3_bucket: Option<String>,
pub s3_key: Option<String>,
}
struct ExportToS3TaskDeserializer;
impl ExportToS3TaskDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExportToS3Task, XmlParseError> {
deserialize_elements::<_, ExportToS3Task, _>(tag_name, stack, |name, stack, obj| {
match name {
"containerFormat" => {
obj.container_format = Some(ContainerFormatDeserializer::deserialize(
"containerFormat",
stack,
)?);
}
"diskImageFormat" => {
obj.disk_image_format = Some(DiskImageFormatDeserializer::deserialize(
"diskImageFormat",
stack,
)?);
}
"s3Bucket" => {
obj.s3_bucket = Some(StringDeserializer::deserialize("s3Bucket", stack)?);
}
"s3Key" => {
obj.s3_key = Some(StringDeserializer::deserialize("s3Key", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportToS3TaskSpecification {
pub container_format: Option<String>,
pub disk_image_format: Option<String>,
pub s3_bucket: Option<String>,
pub s3_prefix: Option<String>,
}
struct ExportToS3TaskSpecificationSerializer;
impl ExportToS3TaskSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ExportToS3TaskSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.container_format {
params.put(&format!("{}{}", prefix, "ContainerFormat"), &field_value);
}
if let Some(ref field_value) = obj.disk_image_format {
params.put(&format!("{}{}", prefix, "DiskImageFormat"), &field_value);
}
if let Some(ref field_value) = obj.s3_bucket {
params.put(&format!("{}{}", prefix, "S3Bucket"), &field_value);
}
if let Some(ref field_value) = obj.s3_prefix {
params.put(&format!("{}{}", prefix, "S3Prefix"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportTransitGatewayRoutesRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub s3_bucket: String,
pub transit_gateway_route_table_id: String,
}
struct ExportTransitGatewayRoutesRequestSerializer;
impl ExportTransitGatewayRoutesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ExportTransitGatewayRoutesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "S3Bucket"), &obj.s3_bucket);
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExportTransitGatewayRoutesResult {
pub s3_location: Option<String>,
}
struct ExportTransitGatewayRoutesResultDeserializer;
impl ExportTransitGatewayRoutesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExportTransitGatewayRoutesResult, XmlParseError> {
deserialize_elements::<_, ExportTransitGatewayRoutesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"s3Location" => {
obj.s3_location =
Some(StringDeserializer::deserialize("s3Location", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Filter {
pub name: Option<String>,
pub values: Option<Vec<String>>,
}
struct FilterSerializer;
impl FilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Filter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
if let Some(ref field_value) = obj.values {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "Value"),
field_value,
);
}
}
}
struct FilterListSerializer;
impl FilterListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Filter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
FilterSerializer::serialize(params, &key, obj);
}
}
}
struct FleetActivityStatusDeserializer;
impl FleetActivityStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetData {
pub activity_status: Option<String>,
pub client_token: Option<String>,
pub create_time: Option<String>,
pub errors: Option<Vec<DescribeFleetError>>,
pub excess_capacity_termination_policy: Option<String>,
pub fleet_id: Option<String>,
pub fleet_state: Option<String>,
pub fulfilled_capacity: Option<f64>,
pub fulfilled_on_demand_capacity: Option<f64>,
pub instances: Option<Vec<DescribeFleetsInstances>>,
pub launch_template_configs: Option<Vec<FleetLaunchTemplateConfig>>,
pub on_demand_options: Option<OnDemandOptions>,
pub replace_unhealthy_instances: Option<bool>,
pub spot_options: Option<SpotOptions>,
pub tags: Option<Vec<Tag>>,
pub target_capacity_specification: Option<TargetCapacitySpecification>,
pub terminate_instances_with_expiration: Option<bool>,
pub type_: Option<String>,
pub valid_from: Option<String>,
pub valid_until: Option<String>,
}
struct FleetDataDeserializer;
impl FleetDataDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FleetData, XmlParseError> {
deserialize_elements::<_, FleetData, _>(tag_name, stack, |name, stack, obj| {
match name {
"activityStatus" => {
obj.activity_status = Some(FleetActivityStatusDeserializer::deserialize(
"activityStatus",
stack,
)?);
}
"clientToken" => {
obj.client_token = Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"errorSet" => {
obj.errors.get_or_insert(vec![]).extend(
DescribeFleetsErrorSetDeserializer::deserialize("errorSet", stack)?,
);
}
"excessCapacityTerminationPolicy" => {
obj.excess_capacity_termination_policy = Some(
FleetExcessCapacityTerminationPolicyDeserializer::deserialize(
"excessCapacityTerminationPolicy",
stack,
)?,
);
}
"fleetId" => {
obj.fleet_id =
Some(FleetIdentifierDeserializer::deserialize("fleetId", stack)?);
}
"fleetState" => {
obj.fleet_state = Some(FleetStateCodeDeserializer::deserialize(
"fleetState",
stack,
)?);
}
"fulfilledCapacity" => {
obj.fulfilled_capacity =
Some(DoubleDeserializer::deserialize("fulfilledCapacity", stack)?);
}
"fulfilledOnDemandCapacity" => {
obj.fulfilled_on_demand_capacity = Some(DoubleDeserializer::deserialize(
"fulfilledOnDemandCapacity",
stack,
)?);
}
"fleetInstanceSet" => {
obj.instances.get_or_insert(vec![]).extend(
DescribeFleetsInstancesSetDeserializer::deserialize(
"fleetInstanceSet",
stack,
)?,
);
}
"launchTemplateConfigs" => {
obj.launch_template_configs.get_or_insert(vec![]).extend(
FleetLaunchTemplateConfigListDeserializer::deserialize(
"launchTemplateConfigs",
stack,
)?,
);
}
"onDemandOptions" => {
obj.on_demand_options = Some(OnDemandOptionsDeserializer::deserialize(
"onDemandOptions",
stack,
)?);
}
"replaceUnhealthyInstances" => {
obj.replace_unhealthy_instances = Some(BooleanDeserializer::deserialize(
"replaceUnhealthyInstances",
stack,
)?);
}
"spotOptions" => {
obj.spot_options =
Some(SpotOptionsDeserializer::deserialize("spotOptions", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"targetCapacitySpecification" => {
obj.target_capacity_specification =
Some(TargetCapacitySpecificationDeserializer::deserialize(
"targetCapacitySpecification",
stack,
)?);
}
"terminateInstancesWithExpiration" => {
obj.terminate_instances_with_expiration =
Some(BooleanDeserializer::deserialize(
"terminateInstancesWithExpiration",
stack,
)?);
}
"type" => {
obj.type_ = Some(FleetTypeDeserializer::deserialize("type", stack)?);
}
"validFrom" => {
obj.valid_from = Some(DateTimeDeserializer::deserialize("validFrom", stack)?);
}
"validUntil" => {
obj.valid_until = Some(DateTimeDeserializer::deserialize("validUntil", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct FleetEventTypeDeserializer;
impl FleetEventTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FleetExcessCapacityTerminationPolicyDeserializer;
impl FleetExcessCapacityTerminationPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FleetIdSetSerializer;
impl FleetIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct FleetIdentifierDeserializer;
impl FleetIdentifierDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetLaunchTemplateConfig {
pub launch_template_specification: Option<FleetLaunchTemplateSpecification>,
pub overrides: Option<Vec<FleetLaunchTemplateOverrides>>,
}
struct FleetLaunchTemplateConfigDeserializer;
impl FleetLaunchTemplateConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FleetLaunchTemplateConfig, XmlParseError> {
deserialize_elements::<_, FleetLaunchTemplateConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateSpecification" => {
obj.launch_template_specification =
Some(FleetLaunchTemplateSpecificationDeserializer::deserialize(
"launchTemplateSpecification",
stack,
)?);
}
"overrides" => {
obj.overrides.get_or_insert(vec![]).extend(
FleetLaunchTemplateOverridesListDeserializer::deserialize(
"overrides",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct FleetLaunchTemplateConfigListDeserializer;
impl FleetLaunchTemplateConfigListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FleetLaunchTemplateConfig>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(FleetLaunchTemplateConfigDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct FleetLaunchTemplateConfigListRequestSerializer;
impl FleetLaunchTemplateConfigListRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<FleetLaunchTemplateConfigRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
FleetLaunchTemplateConfigRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetLaunchTemplateConfigRequest {
pub launch_template_specification: Option<FleetLaunchTemplateSpecificationRequest>,
pub overrides: Option<Vec<FleetLaunchTemplateOverridesRequest>>,
}
struct FleetLaunchTemplateConfigRequestSerializer;
impl FleetLaunchTemplateConfigRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &FleetLaunchTemplateConfigRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_specification {
FleetLaunchTemplateSpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.overrides {
FleetLaunchTemplateOverridesListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Overrides"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetLaunchTemplateOverrides {
pub availability_zone: Option<String>,
pub instance_type: Option<String>,
pub max_price: Option<String>,
pub placement: Option<PlacementResponse>,
pub priority: Option<f64>,
pub subnet_id: Option<String>,
pub weighted_capacity: Option<f64>,
}
struct FleetLaunchTemplateOverridesDeserializer;
impl FleetLaunchTemplateOverridesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FleetLaunchTemplateOverrides, XmlParseError> {
deserialize_elements::<_, FleetLaunchTemplateOverrides, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"maxPrice" => {
obj.max_price = Some(StringDeserializer::deserialize("maxPrice", stack)?);
}
"placement" => {
obj.placement = Some(PlacementResponseDeserializer::deserialize(
"placement",
stack,
)?);
}
"priority" => {
obj.priority = Some(DoubleDeserializer::deserialize("priority", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"weightedCapacity" => {
obj.weighted_capacity =
Some(DoubleDeserializer::deserialize("weightedCapacity", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct FleetLaunchTemplateOverridesListDeserializer;
impl FleetLaunchTemplateOverridesListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FleetLaunchTemplateOverrides>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(FleetLaunchTemplateOverridesDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct FleetLaunchTemplateOverridesListRequestSerializer;
impl FleetLaunchTemplateOverridesListRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<FleetLaunchTemplateOverridesRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
FleetLaunchTemplateOverridesRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetLaunchTemplateOverridesRequest {
pub availability_zone: Option<String>,
pub instance_type: Option<String>,
pub max_price: Option<String>,
pub placement: Option<Placement>,
pub priority: Option<f64>,
pub subnet_id: Option<String>,
pub weighted_capacity: Option<f64>,
}
struct FleetLaunchTemplateOverridesRequestSerializer;
impl FleetLaunchTemplateOverridesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &FleetLaunchTemplateOverridesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.max_price {
params.put(&format!("{}{}", prefix, "MaxPrice"), &field_value);
}
if let Some(ref field_value) = obj.placement {
PlacementSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.priority {
params.put(&format!("{}{}", prefix, "Priority"), &field_value);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.weighted_capacity {
params.put(&format!("{}{}", prefix, "WeightedCapacity"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetLaunchTemplateSpecification {
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub version: Option<String>,
}
struct FleetLaunchTemplateSpecificationDeserializer;
impl FleetLaunchTemplateSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FleetLaunchTemplateSpecification, XmlParseError> {
deserialize_elements::<_, FleetLaunchTemplateSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateId" => {
obj.launch_template_id =
Some(StringDeserializer::deserialize("launchTemplateId", stack)?);
}
"launchTemplateName" => {
obj.launch_template_name =
Some(LaunchTemplateNameDeserializer::deserialize(
"launchTemplateName",
stack,
)?);
}
"version" => {
obj.version = Some(StringDeserializer::deserialize("version", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct FleetLaunchTemplateSpecificationSerializer;
impl FleetLaunchTemplateSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &FleetLaunchTemplateSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
if let Some(ref field_value) = obj.version {
params.put(&format!("{}{}", prefix, "Version"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FleetLaunchTemplateSpecificationRequest {
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub version: Option<String>,
}
struct FleetLaunchTemplateSpecificationRequestSerializer;
impl FleetLaunchTemplateSpecificationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &FleetLaunchTemplateSpecificationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
if let Some(ref field_value) = obj.version {
params.put(&format!("{}{}", prefix, "Version"), &field_value);
}
}
}
struct FleetOnDemandAllocationStrategyDeserializer;
impl FleetOnDemandAllocationStrategyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FleetSetDeserializer;
impl FleetSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FleetData>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(FleetDataDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct FleetStateCodeDeserializer;
impl FleetStateCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FleetTypeDeserializer;
impl FleetTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FloatDeserializer;
impl FloatDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f32, XmlParseError> {
start_element(tag_name, stack)?;
let obj = f32::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FlowLog {
pub creation_time: Option<String>,
pub deliver_logs_error_message: Option<String>,
pub deliver_logs_permission_arn: Option<String>,
pub deliver_logs_status: Option<String>,
pub flow_log_id: Option<String>,
pub flow_log_status: Option<String>,
pub log_destination: Option<String>,
pub log_destination_type: Option<String>,
pub log_group_name: Option<String>,
pub resource_id: Option<String>,
pub traffic_type: Option<String>,
}
struct FlowLogDeserializer;
impl FlowLogDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FlowLog, XmlParseError> {
deserialize_elements::<_, FlowLog, _>(tag_name, stack, |name, stack, obj| {
match name {
"creationTime" => {
obj.creation_time =
Some(DateTimeDeserializer::deserialize("creationTime", stack)?);
}
"deliverLogsErrorMessage" => {
obj.deliver_logs_error_message = Some(StringDeserializer::deserialize(
"deliverLogsErrorMessage",
stack,
)?);
}
"deliverLogsPermissionArn" => {
obj.deliver_logs_permission_arn = Some(StringDeserializer::deserialize(
"deliverLogsPermissionArn",
stack,
)?);
}
"deliverLogsStatus" => {
obj.deliver_logs_status =
Some(StringDeserializer::deserialize("deliverLogsStatus", stack)?);
}
"flowLogId" => {
obj.flow_log_id = Some(StringDeserializer::deserialize("flowLogId", stack)?);
}
"flowLogStatus" => {
obj.flow_log_status =
Some(StringDeserializer::deserialize("flowLogStatus", stack)?);
}
"logDestination" => {
obj.log_destination =
Some(StringDeserializer::deserialize("logDestination", stack)?);
}
"logDestinationType" => {
obj.log_destination_type = Some(LogDestinationTypeDeserializer::deserialize(
"logDestinationType",
stack,
)?);
}
"logGroupName" => {
obj.log_group_name =
Some(StringDeserializer::deserialize("logGroupName", stack)?);
}
"resourceId" => {
obj.resource_id = Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"trafficType" => {
obj.traffic_type =
Some(TrafficTypeDeserializer::deserialize("trafficType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct FlowLogSetDeserializer;
impl FlowLogSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FlowLog>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(FlowLogDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FpgaImage {
pub create_time: Option<String>,
pub data_retention_support: Option<bool>,
pub description: Option<String>,
pub fpga_image_global_id: Option<String>,
pub fpga_image_id: Option<String>,
pub name: Option<String>,
pub owner_alias: Option<String>,
pub owner_id: Option<String>,
pub pci_id: Option<PciId>,
pub product_codes: Option<Vec<ProductCode>>,
pub public: Option<bool>,
pub shell_version: Option<String>,
pub state: Option<FpgaImageState>,
pub tags: Option<Vec<Tag>>,
pub update_time: Option<String>,
}
struct FpgaImageDeserializer;
impl FpgaImageDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FpgaImage, XmlParseError> {
deserialize_elements::<_, FpgaImage, _>(tag_name, stack, |name, stack, obj| {
match name {
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"dataRetentionSupport" => {
obj.data_retention_support = Some(BooleanDeserializer::deserialize(
"dataRetentionSupport",
stack,
)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"fpgaImageGlobalId" => {
obj.fpga_image_global_id =
Some(StringDeserializer::deserialize("fpgaImageGlobalId", stack)?);
}
"fpgaImageId" => {
obj.fpga_image_id =
Some(StringDeserializer::deserialize("fpgaImageId", stack)?);
}
"name" => {
obj.name = Some(StringDeserializer::deserialize("name", stack)?);
}
"ownerAlias" => {
obj.owner_alias = Some(StringDeserializer::deserialize("ownerAlias", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"pciId" => {
obj.pci_id = Some(PciIdDeserializer::deserialize("pciId", stack)?);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"public" => {
obj.public = Some(BooleanDeserializer::deserialize("public", stack)?);
}
"shellVersion" => {
obj.shell_version =
Some(StringDeserializer::deserialize("shellVersion", stack)?);
}
"state" => {
obj.state = Some(FpgaImageStateDeserializer::deserialize("state", stack)?);
}
"tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tags", stack)?);
}
"updateTime" => {
obj.update_time = Some(DateTimeDeserializer::deserialize("updateTime", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FpgaImageAttribute {
pub description: Option<String>,
pub fpga_image_id: Option<String>,
pub load_permissions: Option<Vec<LoadPermission>>,
pub name: Option<String>,
pub product_codes: Option<Vec<ProductCode>>,
}
struct FpgaImageAttributeDeserializer;
impl FpgaImageAttributeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FpgaImageAttribute, XmlParseError> {
deserialize_elements::<_, FpgaImageAttribute, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"fpgaImageId" => {
obj.fpga_image_id =
Some(StringDeserializer::deserialize("fpgaImageId", stack)?);
}
"loadPermissions" => {
obj.load_permissions.get_or_insert(vec![]).extend(
LoadPermissionListDeserializer::deserialize("loadPermissions", stack)?,
);
}
"name" => {
obj.name = Some(StringDeserializer::deserialize("name", stack)?);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct FpgaImageIdListSerializer;
impl FpgaImageIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct FpgaImageListDeserializer;
impl FpgaImageListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FpgaImage>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(FpgaImageDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FpgaImageState {
pub code: Option<String>,
pub message: Option<String>,
}
struct FpgaImageStateDeserializer;
impl FpgaImageStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FpgaImageState, XmlParseError> {
deserialize_elements::<_, FpgaImageState, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(FpgaImageStateCodeDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct FpgaImageStateCodeDeserializer;
impl FpgaImageStateCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct GatewayTypeDeserializer;
impl GatewayTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetConsoleOutputRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
pub latest: Option<bool>,
}
struct GetConsoleOutputRequestSerializer;
impl GetConsoleOutputRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetConsoleOutputRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
if let Some(ref field_value) = obj.latest {
params.put(&format!("{}{}", prefix, "Latest"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetConsoleOutputResult {
pub instance_id: Option<String>,
pub output: Option<String>,
pub timestamp: Option<String>,
}
struct GetConsoleOutputResultDeserializer;
impl GetConsoleOutputResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetConsoleOutputResult, XmlParseError> {
deserialize_elements::<_, GetConsoleOutputResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"output" => {
obj.output = Some(StringDeserializer::deserialize("output", stack)?);
}
"timestamp" => {
obj.timestamp = Some(DateTimeDeserializer::deserialize("timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetConsoleScreenshotRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
pub wake_up: Option<bool>,
}
struct GetConsoleScreenshotRequestSerializer;
impl GetConsoleScreenshotRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetConsoleScreenshotRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
if let Some(ref field_value) = obj.wake_up {
params.put(&format!("{}{}", prefix, "WakeUp"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetConsoleScreenshotResult {
pub image_data: Option<String>,
pub instance_id: Option<String>,
}
struct GetConsoleScreenshotResultDeserializer;
impl GetConsoleScreenshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetConsoleScreenshotResult, XmlParseError> {
deserialize_elements::<_, GetConsoleScreenshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"imageData" => {
obj.image_data = Some(StringDeserializer::deserialize("imageData", stack)?);
}
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetEbsDefaultKmsKeyIdRequest {
pub dry_run: Option<bool>,
}
struct GetEbsDefaultKmsKeyIdRequestSerializer;
impl GetEbsDefaultKmsKeyIdRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetEbsDefaultKmsKeyIdRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetEbsDefaultKmsKeyIdResult {
pub kms_key_id: Option<String>,
}
struct GetEbsDefaultKmsKeyIdResultDeserializer;
impl GetEbsDefaultKmsKeyIdResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetEbsDefaultKmsKeyIdResult, XmlParseError> {
deserialize_elements::<_, GetEbsDefaultKmsKeyIdResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetEbsEncryptionByDefaultRequest {
pub dry_run: Option<bool>,
}
struct GetEbsEncryptionByDefaultRequestSerializer;
impl GetEbsEncryptionByDefaultRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetEbsEncryptionByDefaultRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetEbsEncryptionByDefaultResult {
pub ebs_encryption_by_default: Option<bool>,
}
struct GetEbsEncryptionByDefaultResultDeserializer;
impl GetEbsEncryptionByDefaultResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetEbsEncryptionByDefaultResult, XmlParseError> {
deserialize_elements::<_, GetEbsEncryptionByDefaultResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ebsEncryptionByDefault" => {
obj.ebs_encryption_by_default = Some(BooleanDeserializer::deserialize(
"ebsEncryptionByDefault",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostReservationPurchasePreviewRequest {
pub host_id_set: Vec<String>,
pub offering_id: String,
}
struct GetHostReservationPurchasePreviewRequestSerializer;
impl GetHostReservationPurchasePreviewRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetHostReservationPurchasePreviewRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
RequestHostIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "HostIdSet"),
&obj.host_id_set,
);
params.put(&format!("{}{}", prefix, "OfferingId"), &obj.offering_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostReservationPurchasePreviewResult {
pub currency_code: Option<String>,
pub purchase: Option<Vec<Purchase>>,
pub total_hourly_price: Option<String>,
pub total_upfront_price: Option<String>,
}
struct GetHostReservationPurchasePreviewResultDeserializer;
impl GetHostReservationPurchasePreviewResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHostReservationPurchasePreviewResult, XmlParseError> {
deserialize_elements::<_, GetHostReservationPurchasePreviewResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"purchase" => {
obj.purchase
.get_or_insert(vec![])
.extend(PurchaseSetDeserializer::deserialize("purchase", stack)?);
}
"totalHourlyPrice" => {
obj.total_hourly_price =
Some(StringDeserializer::deserialize("totalHourlyPrice", stack)?);
}
"totalUpfrontPrice" => {
obj.total_upfront_price =
Some(StringDeserializer::deserialize("totalUpfrontPrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetLaunchTemplateDataRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
}
struct GetLaunchTemplateDataRequestSerializer;
impl GetLaunchTemplateDataRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetLaunchTemplateDataRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetLaunchTemplateDataResult {
pub launch_template_data: Option<ResponseLaunchTemplateData>,
}
struct GetLaunchTemplateDataResultDeserializer;
impl GetLaunchTemplateDataResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetLaunchTemplateDataResult, XmlParseError> {
deserialize_elements::<_, GetLaunchTemplateDataResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateData" => {
obj.launch_template_data =
Some(ResponseLaunchTemplateDataDeserializer::deserialize(
"launchTemplateData",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetPasswordDataRequest {
pub dry_run: Option<bool>,
pub instance_id: String,
}
struct GetPasswordDataRequestSerializer;
impl GetPasswordDataRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetPasswordDataRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetPasswordDataResult {
pub instance_id: Option<String>,
pub password_data: Option<String>,
pub timestamp: Option<String>,
}
struct GetPasswordDataResultDeserializer;
impl GetPasswordDataResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetPasswordDataResult, XmlParseError> {
deserialize_elements::<_, GetPasswordDataResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"passwordData" => {
obj.password_data =
Some(StringDeserializer::deserialize("passwordData", stack)?);
}
"timestamp" => {
obj.timestamp = Some(DateTimeDeserializer::deserialize("timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReservedInstancesExchangeQuoteRequest {
pub dry_run: Option<bool>,
pub reserved_instance_ids: Vec<String>,
pub target_configurations: Option<Vec<TargetConfigurationRequest>>,
}
struct GetReservedInstancesExchangeQuoteRequestSerializer;
impl GetReservedInstancesExchangeQuoteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetReservedInstancesExchangeQuoteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
ReservedInstanceIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstanceId"),
&obj.reserved_instance_ids,
);
if let Some(ref field_value) = obj.target_configurations {
TargetConfigurationRequestSetSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetConfiguration"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReservedInstancesExchangeQuoteResult {
pub currency_code: Option<String>,
pub is_valid_exchange: Option<bool>,
pub output_reserved_instances_will_expire_at: Option<String>,
pub payment_due: Option<String>,
pub reserved_instance_value_rollup: Option<ReservationValue>,
pub reserved_instance_value_set: Option<Vec<ReservedInstanceReservationValue>>,
pub target_configuration_value_rollup: Option<ReservationValue>,
pub target_configuration_value_set: Option<Vec<TargetReservationValue>>,
pub validation_failure_reason: Option<String>,
}
struct GetReservedInstancesExchangeQuoteResultDeserializer;
impl GetReservedInstancesExchangeQuoteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetReservedInstancesExchangeQuoteResult, XmlParseError> {
deserialize_elements::<_, GetReservedInstancesExchangeQuoteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"currencyCode" => {
obj.currency_code =
Some(StringDeserializer::deserialize("currencyCode", stack)?);
}
"isValidExchange" => {
obj.is_valid_exchange =
Some(BooleanDeserializer::deserialize("isValidExchange", stack)?);
}
"outputReservedInstancesWillExpireAt" => {
obj.output_reserved_instances_will_expire_at =
Some(DateTimeDeserializer::deserialize(
"outputReservedInstancesWillExpireAt",
stack,
)?);
}
"paymentDue" => {
obj.payment_due =
Some(StringDeserializer::deserialize("paymentDue", stack)?);
}
"reservedInstanceValueRollup" => {
obj.reserved_instance_value_rollup =
Some(ReservationValueDeserializer::deserialize(
"reservedInstanceValueRollup",
stack,
)?);
}
"reservedInstanceValueSet" => {
obj.reserved_instance_value_set
.get_or_insert(vec![])
.extend(
ReservedInstanceReservationValueSetDeserializer::deserialize(
"reservedInstanceValueSet",
stack,
)?,
);
}
"targetConfigurationValueRollup" => {
obj.target_configuration_value_rollup =
Some(ReservationValueDeserializer::deserialize(
"targetConfigurationValueRollup",
stack,
)?);
}
"targetConfigurationValueSet" => {
obj.target_configuration_value_set
.get_or_insert(vec![])
.extend(TargetReservationValueSetDeserializer::deserialize(
"targetConfigurationValueSet",
stack,
)?);
}
"validationFailureReason" => {
obj.validation_failure_reason = Some(StringDeserializer::deserialize(
"validationFailureReason",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTransitGatewayAttachmentPropagationsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_attachment_id: String,
}
struct GetTransitGatewayAttachmentPropagationsRequestSerializer;
impl GetTransitGatewayAttachmentPropagationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &GetTransitGatewayAttachmentPropagationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTransitGatewayAttachmentPropagationsResult {
pub next_token: Option<String>,
pub transit_gateway_attachment_propagations: Option<Vec<TransitGatewayAttachmentPropagation>>,
}
struct GetTransitGatewayAttachmentPropagationsResultDeserializer;
impl GetTransitGatewayAttachmentPropagationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTransitGatewayAttachmentPropagationsResult, XmlParseError> {
deserialize_elements::<_, GetTransitGatewayAttachmentPropagationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"transitGatewayAttachmentPropagations" => {
obj.transit_gateway_attachment_propagations
.get_or_insert(vec![])
.extend(
TransitGatewayAttachmentPropagationListDeserializer::deserialize(
"transitGatewayAttachmentPropagations",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTransitGatewayRouteTableAssociationsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_route_table_id: String,
}
struct GetTransitGatewayRouteTableAssociationsRequestSerializer;
impl GetTransitGatewayRouteTableAssociationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &GetTransitGatewayRouteTableAssociationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTransitGatewayRouteTableAssociationsResult {
pub associations: Option<Vec<TransitGatewayRouteTableAssociation>>,
pub next_token: Option<String>,
}
struct GetTransitGatewayRouteTableAssociationsResultDeserializer;
impl GetTransitGatewayRouteTableAssociationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTransitGatewayRouteTableAssociationsResult, XmlParseError> {
deserialize_elements::<_, GetTransitGatewayRouteTableAssociationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associations" => {
obj.associations.get_or_insert(vec![]).extend(
TransitGatewayRouteTableAssociationListDeserializer::deserialize(
"associations",
stack,
)?,
);
}
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTransitGatewayRouteTablePropagationsRequest {
pub dry_run: Option<bool>,
pub filters: Option<Vec<Filter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub transit_gateway_route_table_id: String,
}
struct GetTransitGatewayRouteTablePropagationsRequestSerializer;
impl GetTransitGatewayRouteTablePropagationsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &GetTransitGatewayRouteTablePropagationsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTransitGatewayRouteTablePropagationsResult {
pub next_token: Option<String>,
pub transit_gateway_route_table_propagations: Option<Vec<TransitGatewayRouteTablePropagation>>,
}
struct GetTransitGatewayRouteTablePropagationsResultDeserializer;
impl GetTransitGatewayRouteTablePropagationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTransitGatewayRouteTablePropagationsResult, XmlParseError> {
deserialize_elements::<_, GetTransitGatewayRouteTablePropagationsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"transitGatewayRouteTablePropagations" => {
obj.transit_gateway_route_table_propagations
.get_or_insert(vec![])
.extend(
TransitGatewayRouteTablePropagationListDeserializer::deserialize(
"transitGatewayRouteTablePropagations",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct GroupIdStringListDeserializer;
impl GroupIdStringListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "groupId" {
obj.push(StringDeserializer::deserialize("groupId", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct GroupIdStringListSerializer;
impl GroupIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GroupIdentifier {
pub group_id: Option<String>,
pub group_name: Option<String>,
}
struct GroupIdentifierDeserializer;
impl GroupIdentifierDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GroupIdentifier, XmlParseError> {
deserialize_elements::<_, GroupIdentifier, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct GroupIdentifierSerializer;
impl GroupIdentifierSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GroupIdentifier) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
}
}
struct GroupIdentifierListDeserializer;
impl GroupIdentifierListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<GroupIdentifier>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(GroupIdentifierDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct GroupIdentifierListSerializer;
impl GroupIdentifierListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<GroupIdentifier>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
GroupIdentifierSerializer::serialize(params, &key, obj);
}
}
}
struct GroupIdentifierSetDeserializer;
impl GroupIdentifierSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SecurityGroupIdentifier>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SecurityGroupIdentifierDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct GroupIdsSerializer;
impl GroupIdsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct GroupNameStringListSerializer;
impl GroupNameStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HibernationOptions {
pub configured: Option<bool>,
}
struct HibernationOptionsDeserializer;
impl HibernationOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HibernationOptions, XmlParseError> {
deserialize_elements::<_, HibernationOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"configured" => {
obj.configured = Some(BooleanDeserializer::deserialize("configured", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HibernationOptionsRequest {
pub configured: Option<bool>,
}
struct HibernationOptionsRequestSerializer;
impl HibernationOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &HibernationOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.configured {
params.put(&format!("{}{}", prefix, "Configured"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HistoryRecord {
pub event_information: Option<EventInformation>,
pub event_type: Option<String>,
pub timestamp: Option<String>,
}
struct HistoryRecordDeserializer;
impl HistoryRecordDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HistoryRecord, XmlParseError> {
deserialize_elements::<_, HistoryRecord, _>(tag_name, stack, |name, stack, obj| {
match name {
"eventInformation" => {
obj.event_information = Some(EventInformationDeserializer::deserialize(
"eventInformation",
stack,
)?);
}
"eventType" => {
obj.event_type = Some(EventTypeDeserializer::deserialize("eventType", stack)?);
}
"timestamp" => {
obj.timestamp = Some(DateTimeDeserializer::deserialize("timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HistoryRecordEntry {
pub event_information: Option<EventInformation>,
pub event_type: Option<String>,
pub timestamp: Option<String>,
}
struct HistoryRecordEntryDeserializer;
impl HistoryRecordEntryDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HistoryRecordEntry, XmlParseError> {
deserialize_elements::<_, HistoryRecordEntry, _>(tag_name, stack, |name, stack, obj| {
match name {
"eventInformation" => {
obj.event_information = Some(EventInformationDeserializer::deserialize(
"eventInformation",
stack,
)?);
}
"eventType" => {
obj.event_type =
Some(FleetEventTypeDeserializer::deserialize("eventType", stack)?);
}
"timestamp" => {
obj.timestamp = Some(DateTimeDeserializer::deserialize("timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct HistoryRecordSetDeserializer;
impl HistoryRecordSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HistoryRecordEntry>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(HistoryRecordEntryDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct HistoryRecordsDeserializer;
impl HistoryRecordsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HistoryRecord>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(HistoryRecordDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Host {
pub allocation_time: Option<String>,
pub auto_placement: Option<String>,
pub availability_zone: Option<String>,
pub available_capacity: Option<AvailableCapacity>,
pub client_token: Option<String>,
pub host_id: Option<String>,
pub host_properties: Option<HostProperties>,
pub host_recovery: Option<String>,
pub host_reservation_id: Option<String>,
pub instances: Option<Vec<HostInstance>>,
pub release_time: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct HostDeserializer;
impl HostDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Host, XmlParseError> {
deserialize_elements::<_, Host, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationTime" => {
obj.allocation_time =
Some(DateTimeDeserializer::deserialize("allocationTime", stack)?);
}
"autoPlacement" => {
obj.auto_placement = Some(AutoPlacementDeserializer::deserialize(
"autoPlacement",
stack,
)?);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"availableCapacity" => {
obj.available_capacity = Some(AvailableCapacityDeserializer::deserialize(
"availableCapacity",
stack,
)?);
}
"clientToken" => {
obj.client_token = Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"hostId" => {
obj.host_id = Some(StringDeserializer::deserialize("hostId", stack)?);
}
"hostProperties" => {
obj.host_properties = Some(HostPropertiesDeserializer::deserialize(
"hostProperties",
stack,
)?);
}
"hostRecovery" => {
obj.host_recovery = Some(HostRecoveryDeserializer::deserialize(
"hostRecovery",
stack,
)?);
}
"hostReservationId" => {
obj.host_reservation_id =
Some(StringDeserializer::deserialize("hostReservationId", stack)?);
}
"instances" => {
obj.instances.get_or_insert(vec![]).extend(
HostInstanceListDeserializer::deserialize("instances", stack)?,
);
}
"releaseTime" => {
obj.release_time =
Some(DateTimeDeserializer::deserialize("releaseTime", stack)?);
}
"state" => {
obj.state = Some(AllocationStateDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostInstance {
pub instance_id: Option<String>,
pub instance_type: Option<String>,
}
struct HostInstanceDeserializer;
impl HostInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostInstance, XmlParseError> {
deserialize_elements::<_, HostInstance, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct HostInstanceListDeserializer;
impl HostInstanceListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HostInstance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(HostInstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct HostListDeserializer;
impl HostListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Host>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(HostDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostOffering {
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub hourly_price: Option<String>,
pub instance_family: Option<String>,
pub offering_id: Option<String>,
pub payment_option: Option<String>,
pub upfront_price: Option<String>,
}
struct HostOfferingDeserializer;
impl HostOfferingDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostOffering, XmlParseError> {
deserialize_elements::<_, HostOffering, _>(tag_name, stack, |name, stack, obj| {
match name {
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("duration", stack)?);
}
"hourlyPrice" => {
obj.hourly_price = Some(StringDeserializer::deserialize("hourlyPrice", stack)?);
}
"instanceFamily" => {
obj.instance_family =
Some(StringDeserializer::deserialize("instanceFamily", stack)?);
}
"offeringId" => {
obj.offering_id = Some(StringDeserializer::deserialize("offeringId", stack)?);
}
"paymentOption" => {
obj.payment_option = Some(PaymentOptionDeserializer::deserialize(
"paymentOption",
stack,
)?);
}
"upfrontPrice" => {
obj.upfront_price =
Some(StringDeserializer::deserialize("upfrontPrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct HostOfferingSetDeserializer;
impl HostOfferingSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HostOffering>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(HostOfferingDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostProperties {
pub cores: Option<i64>,
pub instance_type: Option<String>,
pub sockets: Option<i64>,
pub total_v_cpus: Option<i64>,
}
struct HostPropertiesDeserializer;
impl HostPropertiesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostProperties, XmlParseError> {
deserialize_elements::<_, HostProperties, _>(tag_name, stack, |name, stack, obj| {
match name {
"cores" => {
obj.cores = Some(IntegerDeserializer::deserialize("cores", stack)?);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
"sockets" => {
obj.sockets = Some(IntegerDeserializer::deserialize("sockets", stack)?);
}
"totalVCpus" => {
obj.total_v_cpus = Some(IntegerDeserializer::deserialize("totalVCpus", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct HostRecoveryDeserializer;
impl HostRecoveryDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostReservation {
pub count: Option<i64>,
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub end: Option<String>,
pub host_id_set: Option<Vec<String>>,
pub host_reservation_id: Option<String>,
pub hourly_price: Option<String>,
pub instance_family: Option<String>,
pub offering_id: Option<String>,
pub payment_option: Option<String>,
pub start: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub upfront_price: Option<String>,
}
struct HostReservationDeserializer;
impl HostReservationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostReservation, XmlParseError> {
deserialize_elements::<_, HostReservation, _>(tag_name, stack, |name, stack, obj| {
match name {
"count" => {
obj.count = Some(IntegerDeserializer::deserialize("count", stack)?);
}
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("duration", stack)?);
}
"end" => {
obj.end = Some(DateTimeDeserializer::deserialize("end", stack)?);
}
"hostIdSet" => {
obj.host_id_set.get_or_insert(vec![]).extend(
ResponseHostIdSetDeserializer::deserialize("hostIdSet", stack)?,
);
}
"hostReservationId" => {
obj.host_reservation_id =
Some(StringDeserializer::deserialize("hostReservationId", stack)?);
}
"hourlyPrice" => {
obj.hourly_price = Some(StringDeserializer::deserialize("hourlyPrice", stack)?);
}
"instanceFamily" => {
obj.instance_family =
Some(StringDeserializer::deserialize("instanceFamily", stack)?);
}
"offeringId" => {
obj.offering_id = Some(StringDeserializer::deserialize("offeringId", stack)?);
}
"paymentOption" => {
obj.payment_option = Some(PaymentOptionDeserializer::deserialize(
"paymentOption",
stack,
)?);
}
"start" => {
obj.start = Some(DateTimeDeserializer::deserialize("start", stack)?);
}
"state" => {
obj.state = Some(ReservationStateDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"upfrontPrice" => {
obj.upfront_price =
Some(StringDeserializer::deserialize("upfrontPrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct HostReservationIdSetSerializer;
impl HostReservationIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct HostReservationSetDeserializer;
impl HostReservationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HostReservation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(HostReservationDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct HypervisorTypeDeserializer;
impl HypervisorTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IamInstanceProfile {
pub arn: Option<String>,
pub id: Option<String>,
}
struct IamInstanceProfileDeserializer;
impl IamInstanceProfileDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IamInstanceProfile, XmlParseError> {
deserialize_elements::<_, IamInstanceProfile, _>(tag_name, stack, |name, stack, obj| {
match name {
"arn" => {
obj.arn = Some(StringDeserializer::deserialize("arn", stack)?);
}
"id" => {
obj.id = Some(StringDeserializer::deserialize("id", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IamInstanceProfileAssociation {
pub association_id: Option<String>,
pub iam_instance_profile: Option<IamInstanceProfile>,
pub instance_id: Option<String>,
pub state: Option<String>,
pub timestamp: Option<String>,
}
struct IamInstanceProfileAssociationDeserializer;
impl IamInstanceProfileAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IamInstanceProfileAssociation, XmlParseError> {
deserialize_elements::<_, IamInstanceProfileAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"iamInstanceProfile" => {
obj.iam_instance_profile =
Some(IamInstanceProfileDeserializer::deserialize(
"iamInstanceProfile",
stack,
)?);
}
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"state" => {
obj.state =
Some(IamInstanceProfileAssociationStateDeserializer::deserialize(
"state", stack,
)?);
}
"timestamp" => {
obj.timestamp =
Some(DateTimeDeserializer::deserialize("timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct IamInstanceProfileAssociationSetDeserializer;
impl IamInstanceProfileAssociationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IamInstanceProfileAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(IamInstanceProfileAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct IamInstanceProfileAssociationStateDeserializer;
impl IamInstanceProfileAssociationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IamInstanceProfileSpecification {
pub arn: Option<String>,
pub name: Option<String>,
}
struct IamInstanceProfileSpecificationDeserializer;
impl IamInstanceProfileSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IamInstanceProfileSpecification, XmlParseError> {
deserialize_elements::<_, IamInstanceProfileSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"arn" => {
obj.arn = Some(StringDeserializer::deserialize("arn", stack)?);
}
"name" => {
obj.name = Some(StringDeserializer::deserialize("name", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct IamInstanceProfileSpecificationSerializer;
impl IamInstanceProfileSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IamInstanceProfileSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.arn {
params.put(&format!("{}{}", prefix, "Arn"), &field_value);
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IcmpTypeCode {
pub code: Option<i64>,
pub type_: Option<i64>,
}
struct IcmpTypeCodeDeserializer;
impl IcmpTypeCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IcmpTypeCode, XmlParseError> {
deserialize_elements::<_, IcmpTypeCode, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(IntegerDeserializer::deserialize("code", stack)?);
}
"type" => {
obj.type_ = Some(IntegerDeserializer::deserialize("type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IcmpTypeCodeSerializer;
impl IcmpTypeCodeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IcmpTypeCode) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.code {
params.put(&format!("{}{}", prefix, "Code"), &field_value);
}
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IdFormat {
pub deadline: Option<String>,
pub resource: Option<String>,
pub use_long_ids: Option<bool>,
}
struct IdFormatDeserializer;
impl IdFormatDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IdFormat, XmlParseError> {
deserialize_elements::<_, IdFormat, _>(tag_name, stack, |name, stack, obj| {
match name {
"deadline" => {
obj.deadline = Some(DateTimeDeserializer::deserialize("deadline", stack)?);
}
"resource" => {
obj.resource = Some(StringDeserializer::deserialize("resource", stack)?);
}
"useLongIds" => {
obj.use_long_ids = Some(BooleanDeserializer::deserialize("useLongIds", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IdFormatListDeserializer;
impl IdFormatListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IdFormat>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(IdFormatDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Image {
pub architecture: Option<String>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub creation_date: Option<String>,
pub description: Option<String>,
pub ena_support: Option<bool>,
pub hypervisor: Option<String>,
pub image_id: Option<String>,
pub image_location: Option<String>,
pub image_owner_alias: Option<String>,
pub image_type: Option<String>,
pub kernel_id: Option<String>,
pub name: Option<String>,
pub owner_id: Option<String>,
pub platform: Option<String>,
pub product_codes: Option<Vec<ProductCode>>,
pub public: Option<bool>,
pub ramdisk_id: Option<String>,
pub root_device_name: Option<String>,
pub root_device_type: Option<String>,
pub sriov_net_support: Option<String>,
pub state: Option<String>,
pub state_reason: Option<StateReason>,
pub tags: Option<Vec<Tag>>,
pub virtualization_type: Option<String>,
}
struct ImageDeserializer;
impl ImageDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Image, XmlParseError> {
deserialize_elements::<_, Image, _>(tag_name, stack, |name, stack, obj| {
match name {
"architecture" => {
obj.architecture = Some(ArchitectureValuesDeserializer::deserialize(
"architecture",
stack,
)?);
}
"blockDeviceMapping" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
BlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMapping",
stack,
)?,
);
}
"creationDate" => {
obj.creation_date =
Some(StringDeserializer::deserialize("creationDate", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"enaSupport" => {
obj.ena_support = Some(BooleanDeserializer::deserialize("enaSupport", stack)?);
}
"hypervisor" => {
obj.hypervisor = Some(HypervisorTypeDeserializer::deserialize(
"hypervisor",
stack,
)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"imageLocation" => {
obj.image_location =
Some(StringDeserializer::deserialize("imageLocation", stack)?);
}
"imageOwnerAlias" => {
obj.image_owner_alias =
Some(StringDeserializer::deserialize("imageOwnerAlias", stack)?);
}
"imageType" => {
obj.image_type = Some(ImageTypeValuesDeserializer::deserialize(
"imageType",
stack,
)?);
}
"kernelId" => {
obj.kernel_id = Some(StringDeserializer::deserialize("kernelId", stack)?);
}
"name" => {
obj.name = Some(StringDeserializer::deserialize("name", stack)?);
}
"imageOwnerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("imageOwnerId", stack)?);
}
"platform" => {
obj.platform =
Some(PlatformValuesDeserializer::deserialize("platform", stack)?);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"isPublic" => {
obj.public = Some(BooleanDeserializer::deserialize("isPublic", stack)?);
}
"ramdiskId" => {
obj.ramdisk_id = Some(StringDeserializer::deserialize("ramdiskId", stack)?);
}
"rootDeviceName" => {
obj.root_device_name =
Some(StringDeserializer::deserialize("rootDeviceName", stack)?);
}
"rootDeviceType" => {
obj.root_device_type = Some(DeviceTypeDeserializer::deserialize(
"rootDeviceType",
stack,
)?);
}
"sriovNetSupport" => {
obj.sriov_net_support =
Some(StringDeserializer::deserialize("sriovNetSupport", stack)?);
}
"imageState" => {
obj.state = Some(ImageStateDeserializer::deserialize("imageState", stack)?);
}
"stateReason" => {
obj.state_reason =
Some(StateReasonDeserializer::deserialize("stateReason", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"virtualizationType" => {
obj.virtualization_type = Some(VirtualizationTypeDeserializer::deserialize(
"virtualizationType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImageAttribute {
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub description: Option<AttributeValue>,
pub image_id: Option<String>,
pub kernel_id: Option<AttributeValue>,
pub launch_permissions: Option<Vec<LaunchPermission>>,
pub product_codes: Option<Vec<ProductCode>>,
pub ramdisk_id: Option<AttributeValue>,
pub sriov_net_support: Option<AttributeValue>,
}
struct ImageAttributeDeserializer;
impl ImageAttributeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImageAttribute, XmlParseError> {
deserialize_elements::<_, ImageAttribute, _>(tag_name, stack, |name, stack, obj| {
match name {
"blockDeviceMapping" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
BlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMapping",
stack,
)?,
);
}
"description" => {
obj.description = Some(AttributeValueDeserializer::deserialize(
"description",
stack,
)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"kernel" => {
obj.kernel_id = Some(AttributeValueDeserializer::deserialize("kernel", stack)?);
}
"launchPermission" => {
obj.launch_permissions.get_or_insert(vec![]).extend(
LaunchPermissionListDeserializer::deserialize("launchPermission", stack)?,
);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"ramdisk" => {
obj.ramdisk_id =
Some(AttributeValueDeserializer::deserialize("ramdisk", stack)?);
}
"sriovNetSupport" => {
obj.sriov_net_support = Some(AttributeValueDeserializer::deserialize(
"sriovNetSupport",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImageDiskContainer {
pub description: Option<String>,
pub device_name: Option<String>,
pub format: Option<String>,
pub snapshot_id: Option<String>,
pub url: Option<String>,
pub user_bucket: Option<UserBucket>,
}
struct ImageDiskContainerSerializer;
impl ImageDiskContainerSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImageDiskContainer) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.device_name {
params.put(&format!("{}{}", prefix, "DeviceName"), &field_value);
}
if let Some(ref field_value) = obj.format {
params.put(&format!("{}{}", prefix, "Format"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_id {
params.put(&format!("{}{}", prefix, "SnapshotId"), &field_value);
}
if let Some(ref field_value) = obj.url {
params.put(&format!("{}{}", prefix, "Url"), &field_value);
}
if let Some(ref field_value) = obj.user_bucket {
UserBucketSerializer::serialize(
params,
&format!("{}{}", prefix, "UserBucket"),
field_value,
);
}
}
}
struct ImageDiskContainerListSerializer;
impl ImageDiskContainerListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ImageDiskContainer>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ImageDiskContainerSerializer::serialize(params, &key, obj);
}
}
}
struct ImageIdStringListSerializer;
impl ImageIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ImageListDeserializer;
impl ImageListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Image>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ImageDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ImageStateDeserializer;
impl ImageStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ImageTypeValuesDeserializer;
impl ImageTypeValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportClientVpnClientCertificateRevocationListRequest {
pub certificate_revocation_list: String,
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
}
struct ImportClientVpnClientCertificateRevocationListRequestSerializer;
impl ImportClientVpnClientCertificateRevocationListRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ImportClientVpnClientCertificateRevocationListRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CertificateRevocationList"),
&obj.certificate_revocation_list,
);
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportClientVpnClientCertificateRevocationListResult {
pub return_: Option<bool>,
}
struct ImportClientVpnClientCertificateRevocationListResultDeserializer;
impl ImportClientVpnClientCertificateRevocationListResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportClientVpnClientCertificateRevocationListResult, XmlParseError> {
deserialize_elements::<_, ImportClientVpnClientCertificateRevocationListResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportImageRequest {
pub architecture: Option<String>,
pub client_data: Option<ClientData>,
pub client_token: Option<String>,
pub description: Option<String>,
pub disk_containers: Option<Vec<ImageDiskContainer>>,
pub dry_run: Option<bool>,
pub encrypted: Option<bool>,
pub hypervisor: Option<String>,
pub kms_key_id: Option<String>,
pub license_type: Option<String>,
pub platform: Option<String>,
pub role_name: Option<String>,
}
struct ImportImageRequestSerializer;
impl ImportImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImportImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.architecture {
params.put(&format!("{}{}", prefix, "Architecture"), &field_value);
}
if let Some(ref field_value) = obj.client_data {
ClientDataSerializer::serialize(
params,
&format!("{}{}", prefix, "ClientData"),
field_value,
);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.disk_containers {
ImageDiskContainerListSerializer::serialize(
params,
&format!("{}{}", prefix, "DiskContainer"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.hypervisor {
params.put(&format!("{}{}", prefix, "Hypervisor"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.license_type {
params.put(&format!("{}{}", prefix, "LicenseType"), &field_value);
}
if let Some(ref field_value) = obj.platform {
params.put(&format!("{}{}", prefix, "Platform"), &field_value);
}
if let Some(ref field_value) = obj.role_name {
params.put(&format!("{}{}", prefix, "RoleName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportImageResult {
pub architecture: Option<String>,
pub description: Option<String>,
pub encrypted: Option<bool>,
pub hypervisor: Option<String>,
pub image_id: Option<String>,
pub import_task_id: Option<String>,
pub kms_key_id: Option<String>,
pub license_type: Option<String>,
pub platform: Option<String>,
pub progress: Option<String>,
pub snapshot_details: Option<Vec<SnapshotDetail>>,
pub status: Option<String>,
pub status_message: Option<String>,
}
struct ImportImageResultDeserializer;
impl ImportImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportImageResult, XmlParseError> {
deserialize_elements::<_, ImportImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"architecture" => {
obj.architecture =
Some(StringDeserializer::deserialize("architecture", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"hypervisor" => {
obj.hypervisor = Some(StringDeserializer::deserialize("hypervisor", stack)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"importTaskId" => {
obj.import_task_id =
Some(StringDeserializer::deserialize("importTaskId", stack)?);
}
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
"licenseType" => {
obj.license_type = Some(StringDeserializer::deserialize("licenseType", stack)?);
}
"platform" => {
obj.platform = Some(StringDeserializer::deserialize("platform", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"snapshotDetailSet" => {
obj.snapshot_details.get_or_insert(vec![]).extend(
SnapshotDetailListDeserializer::deserialize("snapshotDetailSet", stack)?,
);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportImageTask {
pub architecture: Option<String>,
pub description: Option<String>,
pub encrypted: Option<bool>,
pub hypervisor: Option<String>,
pub image_id: Option<String>,
pub import_task_id: Option<String>,
pub kms_key_id: Option<String>,
pub license_type: Option<String>,
pub platform: Option<String>,
pub progress: Option<String>,
pub snapshot_details: Option<Vec<SnapshotDetail>>,
pub status: Option<String>,
pub status_message: Option<String>,
}
struct ImportImageTaskDeserializer;
impl ImportImageTaskDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportImageTask, XmlParseError> {
deserialize_elements::<_, ImportImageTask, _>(tag_name, stack, |name, stack, obj| {
match name {
"architecture" => {
obj.architecture =
Some(StringDeserializer::deserialize("architecture", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"hypervisor" => {
obj.hypervisor = Some(StringDeserializer::deserialize("hypervisor", stack)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"importTaskId" => {
obj.import_task_id =
Some(StringDeserializer::deserialize("importTaskId", stack)?);
}
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
"licenseType" => {
obj.license_type = Some(StringDeserializer::deserialize("licenseType", stack)?);
}
"platform" => {
obj.platform = Some(StringDeserializer::deserialize("platform", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"snapshotDetailSet" => {
obj.snapshot_details.get_or_insert(vec![]).extend(
SnapshotDetailListDeserializer::deserialize("snapshotDetailSet", stack)?,
);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ImportImageTaskListDeserializer;
impl ImportImageTaskListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ImportImageTask>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ImportImageTaskDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportInstanceLaunchSpecification {
pub additional_info: Option<String>,
pub architecture: Option<String>,
pub group_ids: Option<Vec<String>>,
pub group_names: Option<Vec<String>>,
pub instance_initiated_shutdown_behavior: Option<String>,
pub instance_type: Option<String>,
pub monitoring: Option<bool>,
pub placement: Option<Placement>,
pub private_ip_address: Option<String>,
pub subnet_id: Option<String>,
pub user_data: Option<UserData>,
}
struct ImportInstanceLaunchSpecificationSerializer;
impl ImportInstanceLaunchSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImportInstanceLaunchSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.additional_info {
params.put(&format!("{}{}", prefix, "AdditionalInfo"), &field_value);
}
if let Some(ref field_value) = obj.architecture {
params.put(&format!("{}{}", prefix, "Architecture"), &field_value);
}
if let Some(ref field_value) = obj.group_ids {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.group_names {
SecurityGroupStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_initiated_shutdown_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInitiatedShutdownBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.monitoring {
params.put(&format!("{}{}", prefix, "Monitoring"), &field_value);
}
if let Some(ref field_value) = obj.placement {
PlacementSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.user_data {
UserDataSerializer::serialize(
params,
&format!("{}{}", prefix, "UserData"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportInstanceRequest {
pub description: Option<String>,
pub disk_images: Option<Vec<DiskImage>>,
pub dry_run: Option<bool>,
pub launch_specification: Option<ImportInstanceLaunchSpecification>,
pub platform: String,
}
struct ImportInstanceRequestSerializer;
impl ImportInstanceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImportInstanceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.disk_images {
DiskImageListSerializer::serialize(
params,
&format!("{}{}", prefix, "DiskImage"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.launch_specification {
ImportInstanceLaunchSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchSpecification"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "Platform"), &obj.platform);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportInstanceResult {
pub conversion_task: Option<ConversionTask>,
}
struct ImportInstanceResultDeserializer;
impl ImportInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportInstanceResult, XmlParseError> {
deserialize_elements::<_, ImportInstanceResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"conversionTask" => {
obj.conversion_task = Some(ConversionTaskDeserializer::deserialize(
"conversionTask",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportInstanceTaskDetails {
pub description: Option<String>,
pub instance_id: Option<String>,
pub platform: Option<String>,
pub volumes: Option<Vec<ImportInstanceVolumeDetailItem>>,
}
struct ImportInstanceTaskDetailsDeserializer;
impl ImportInstanceTaskDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportInstanceTaskDetails, XmlParseError> {
deserialize_elements::<_, ImportInstanceTaskDetails, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"description" => {
obj.description =
Some(StringDeserializer::deserialize("description", stack)?);
}
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"platform" => {
obj.platform =
Some(PlatformValuesDeserializer::deserialize("platform", stack)?);
}
"volumes" => {
obj.volumes.get_or_insert(vec![]).extend(
ImportInstanceVolumeDetailSetDeserializer::deserialize(
"volumes", stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportInstanceVolumeDetailItem {
pub availability_zone: Option<String>,
pub bytes_converted: Option<i64>,
pub description: Option<String>,
pub image: Option<DiskImageDescription>,
pub status: Option<String>,
pub status_message: Option<String>,
pub volume: Option<DiskImageVolumeDescription>,
}
struct ImportInstanceVolumeDetailItemDeserializer;
impl ImportInstanceVolumeDetailItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportInstanceVolumeDetailItem, XmlParseError> {
deserialize_elements::<_, ImportInstanceVolumeDetailItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"bytesConverted" => {
obj.bytes_converted =
Some(LongDeserializer::deserialize("bytesConverted", stack)?);
}
"description" => {
obj.description =
Some(StringDeserializer::deserialize("description", stack)?);
}
"image" => {
obj.image = Some(DiskImageDescriptionDeserializer::deserialize(
"image", stack,
)?);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"volume" => {
obj.volume = Some(DiskImageVolumeDescriptionDeserializer::deserialize(
"volume", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ImportInstanceVolumeDetailSetDeserializer;
impl ImportInstanceVolumeDetailSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ImportInstanceVolumeDetailItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ImportInstanceVolumeDetailItemDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportKeyPairRequest {
pub dry_run: Option<bool>,
pub key_name: String,
pub public_key_material: bytes::Bytes,
}
struct ImportKeyPairRequestSerializer;
impl ImportKeyPairRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImportKeyPairRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "KeyName"), &obj.key_name);
params.put(
&format!("{}{}", prefix, "PublicKeyMaterial"),
::std::str::from_utf8(&obj.public_key_material).unwrap(),
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportKeyPairResult {
pub key_fingerprint: Option<String>,
pub key_name: Option<String>,
}
struct ImportKeyPairResultDeserializer;
impl ImportKeyPairResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportKeyPairResult, XmlParseError> {
deserialize_elements::<_, ImportKeyPairResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"keyFingerprint" => {
obj.key_fingerprint =
Some(StringDeserializer::deserialize("keyFingerprint", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportSnapshotRequest {
pub client_data: Option<ClientData>,
pub client_token: Option<String>,
pub description: Option<String>,
pub disk_container: Option<SnapshotDiskContainer>,
pub dry_run: Option<bool>,
pub encrypted: Option<bool>,
pub kms_key_id: Option<String>,
pub role_name: Option<String>,
}
struct ImportSnapshotRequestSerializer;
impl ImportSnapshotRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImportSnapshotRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_data {
ClientDataSerializer::serialize(
params,
&format!("{}{}", prefix, "ClientData"),
field_value,
);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.disk_container {
SnapshotDiskContainerSerializer::serialize(
params,
&format!("{}{}", prefix, "DiskContainer"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.role_name {
params.put(&format!("{}{}", prefix, "RoleName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportSnapshotResult {
pub description: Option<String>,
pub import_task_id: Option<String>,
pub snapshot_task_detail: Option<SnapshotTaskDetail>,
}
struct ImportSnapshotResultDeserializer;
impl ImportSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportSnapshotResult, XmlParseError> {
deserialize_elements::<_, ImportSnapshotResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"importTaskId" => {
obj.import_task_id =
Some(StringDeserializer::deserialize("importTaskId", stack)?);
}
"snapshotTaskDetail" => {
obj.snapshot_task_detail = Some(SnapshotTaskDetailDeserializer::deserialize(
"snapshotTaskDetail",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportSnapshotTask {
pub description: Option<String>,
pub import_task_id: Option<String>,
pub snapshot_task_detail: Option<SnapshotTaskDetail>,
}
struct ImportSnapshotTaskDeserializer;
impl ImportSnapshotTaskDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportSnapshotTask, XmlParseError> {
deserialize_elements::<_, ImportSnapshotTask, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"importTaskId" => {
obj.import_task_id =
Some(StringDeserializer::deserialize("importTaskId", stack)?);
}
"snapshotTaskDetail" => {
obj.snapshot_task_detail = Some(SnapshotTaskDetailDeserializer::deserialize(
"snapshotTaskDetail",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ImportSnapshotTaskListDeserializer;
impl ImportSnapshotTaskListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ImportSnapshotTask>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ImportSnapshotTaskDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ImportTaskIdListSerializer;
impl ImportTaskIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportVolumeRequest {
pub availability_zone: String,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub image: DiskImageDetail,
pub volume: VolumeDetail,
}
struct ImportVolumeRequestSerializer;
impl ImportVolumeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ImportVolumeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AvailabilityZone"),
&obj.availability_zone,
);
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
DiskImageDetailSerializer::serialize(params, &format!("{}{}", prefix, "Image"), &obj.image);
VolumeDetailSerializer::serialize(params, &format!("{}{}", prefix, "Volume"), &obj.volume);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportVolumeResult {
pub conversion_task: Option<ConversionTask>,
}
struct ImportVolumeResultDeserializer;
impl ImportVolumeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportVolumeResult, XmlParseError> {
deserialize_elements::<_, ImportVolumeResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"conversionTask" => {
obj.conversion_task = Some(ConversionTaskDeserializer::deserialize(
"conversionTask",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ImportVolumeTaskDetails {
pub availability_zone: Option<String>,
pub bytes_converted: Option<i64>,
pub description: Option<String>,
pub image: Option<DiskImageDescription>,
pub volume: Option<DiskImageVolumeDescription>,
}
struct ImportVolumeTaskDetailsDeserializer;
impl ImportVolumeTaskDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ImportVolumeTaskDetails, XmlParseError> {
deserialize_elements::<_, ImportVolumeTaskDetails, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"bytesConverted" => {
obj.bytes_converted =
Some(LongDeserializer::deserialize("bytesConverted", stack)?);
}
"description" => {
obj.description =
Some(StringDeserializer::deserialize("description", stack)?);
}
"image" => {
obj.image = Some(DiskImageDescriptionDeserializer::deserialize(
"image", stack,
)?);
}
"volume" => {
obj.volume = Some(DiskImageVolumeDescriptionDeserializer::deserialize(
"volume", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Instance {
pub ami_launch_index: Option<i64>,
pub architecture: Option<String>,
pub block_device_mappings: Option<Vec<InstanceBlockDeviceMapping>>,
pub capacity_reservation_id: Option<String>,
pub capacity_reservation_specification: Option<CapacityReservationSpecificationResponse>,
pub client_token: Option<String>,
pub cpu_options: Option<CpuOptions>,
pub ebs_optimized: Option<bool>,
pub elastic_gpu_associations: Option<Vec<ElasticGpuAssociation>>,
pub elastic_inference_accelerator_associations:
Option<Vec<ElasticInferenceAcceleratorAssociation>>,
pub ena_support: Option<bool>,
pub hibernation_options: Option<HibernationOptions>,
pub hypervisor: Option<String>,
pub iam_instance_profile: Option<IamInstanceProfile>,
pub image_id: Option<String>,
pub instance_id: Option<String>,
pub instance_lifecycle: Option<String>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub launch_time: Option<String>,
pub licenses: Option<Vec<LicenseConfiguration>>,
pub monitoring: Option<Monitoring>,
pub network_interfaces: Option<Vec<InstanceNetworkInterface>>,
pub placement: Option<Placement>,
pub platform: Option<String>,
pub private_dns_name: Option<String>,
pub private_ip_address: Option<String>,
pub product_codes: Option<Vec<ProductCode>>,
pub public_dns_name: Option<String>,
pub public_ip_address: Option<String>,
pub ramdisk_id: Option<String>,
pub root_device_name: Option<String>,
pub root_device_type: Option<String>,
pub security_groups: Option<Vec<GroupIdentifier>>,
pub source_dest_check: Option<bool>,
pub spot_instance_request_id: Option<String>,
pub sriov_net_support: Option<String>,
pub state: Option<InstanceState>,
pub state_reason: Option<StateReason>,
pub state_transition_reason: Option<String>,
pub subnet_id: Option<String>,
pub tags: Option<Vec<Tag>>,
pub virtualization_type: Option<String>,
pub vpc_id: Option<String>,
}
struct InstanceDeserializer;
impl InstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Instance, XmlParseError> {
deserialize_elements::<_, Instance, _>(tag_name, stack, |name, stack, obj| {
match name {
"amiLaunchIndex" => {
obj.ami_launch_index =
Some(IntegerDeserializer::deserialize("amiLaunchIndex", stack)?);
}
"architecture" => {
obj.architecture = Some(ArchitectureValuesDeserializer::deserialize(
"architecture",
stack,
)?);
}
"blockDeviceMapping" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
InstanceBlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMapping",
stack,
)?,
);
}
"capacityReservationId" => {
obj.capacity_reservation_id = Some(StringDeserializer::deserialize(
"capacityReservationId",
stack,
)?);
}
"capacityReservationSpecification" => {
obj.capacity_reservation_specification = Some(
CapacityReservationSpecificationResponseDeserializer::deserialize(
"capacityReservationSpecification",
stack,
)?,
);
}
"clientToken" => {
obj.client_token = Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"cpuOptions" => {
obj.cpu_options =
Some(CpuOptionsDeserializer::deserialize("cpuOptions", stack)?);
}
"ebsOptimized" => {
obj.ebs_optimized =
Some(BooleanDeserializer::deserialize("ebsOptimized", stack)?);
}
"elasticGpuAssociationSet" => {
obj.elastic_gpu_associations.get_or_insert(vec![]).extend(
ElasticGpuAssociationListDeserializer::deserialize(
"elasticGpuAssociationSet",
stack,
)?,
);
}
"elasticInferenceAcceleratorAssociationSet" => {
obj.elastic_inference_accelerator_associations
.get_or_insert(vec![])
.extend(
ElasticInferenceAcceleratorAssociationListDeserializer::deserialize(
"elasticInferenceAcceleratorAssociationSet",
stack,
)?,
);
}
"enaSupport" => {
obj.ena_support = Some(BooleanDeserializer::deserialize("enaSupport", stack)?);
}
"hibernationOptions" => {
obj.hibernation_options = Some(HibernationOptionsDeserializer::deserialize(
"hibernationOptions",
stack,
)?);
}
"hypervisor" => {
obj.hypervisor = Some(HypervisorTypeDeserializer::deserialize(
"hypervisor",
stack,
)?);
}
"iamInstanceProfile" => {
obj.iam_instance_profile = Some(IamInstanceProfileDeserializer::deserialize(
"iamInstanceProfile",
stack,
)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceLifecycle" => {
obj.instance_lifecycle = Some(InstanceLifecycleTypeDeserializer::deserialize(
"instanceLifecycle",
stack,
)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"kernelId" => {
obj.kernel_id = Some(StringDeserializer::deserialize("kernelId", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
"launchTime" => {
obj.launch_time = Some(DateTimeDeserializer::deserialize("launchTime", stack)?);
}
"licenseSet" => {
obj.licenses
.get_or_insert(vec![])
.extend(LicenseListDeserializer::deserialize("licenseSet", stack)?);
}
"monitoring" => {
obj.monitoring =
Some(MonitoringDeserializer::deserialize("monitoring", stack)?);
}
"networkInterfaceSet" => {
obj.network_interfaces.get_or_insert(vec![]).extend(
InstanceNetworkInterfaceListDeserializer::deserialize(
"networkInterfaceSet",
stack,
)?,
);
}
"placement" => {
obj.placement = Some(PlacementDeserializer::deserialize("placement", stack)?);
}
"platform" => {
obj.platform =
Some(PlatformValuesDeserializer::deserialize("platform", stack)?);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"dnsName" => {
obj.public_dns_name = Some(StringDeserializer::deserialize("dnsName", stack)?);
}
"ipAddress" => {
obj.public_ip_address =
Some(StringDeserializer::deserialize("ipAddress", stack)?);
}
"ramdiskId" => {
obj.ramdisk_id = Some(StringDeserializer::deserialize("ramdiskId", stack)?);
}
"rootDeviceName" => {
obj.root_device_name =
Some(StringDeserializer::deserialize("rootDeviceName", stack)?);
}
"rootDeviceType" => {
obj.root_device_type = Some(DeviceTypeDeserializer::deserialize(
"rootDeviceType",
stack,
)?);
}
"groupSet" => {
obj.security_groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"sourceDestCheck" => {
obj.source_dest_check =
Some(BooleanDeserializer::deserialize("sourceDestCheck", stack)?);
}
"spotInstanceRequestId" => {
obj.spot_instance_request_id = Some(StringDeserializer::deserialize(
"spotInstanceRequestId",
stack,
)?);
}
"sriovNetSupport" => {
obj.sriov_net_support =
Some(StringDeserializer::deserialize("sriovNetSupport", stack)?);
}
"instanceState" => {
obj.state = Some(InstanceStateDeserializer::deserialize(
"instanceState",
stack,
)?);
}
"stateReason" => {
obj.state_reason =
Some(StateReasonDeserializer::deserialize("stateReason", stack)?);
}
"reason" => {
obj.state_transition_reason =
Some(StringDeserializer::deserialize("reason", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"virtualizationType" => {
obj.virtualization_type = Some(VirtualizationTypeDeserializer::deserialize(
"virtualizationType",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceAttribute {
pub block_device_mappings: Option<Vec<InstanceBlockDeviceMapping>>,
pub disable_api_termination: Option<AttributeBooleanValue>,
pub ebs_optimized: Option<AttributeBooleanValue>,
pub ena_support: Option<AttributeBooleanValue>,
pub groups: Option<Vec<GroupIdentifier>>,
pub instance_id: Option<String>,
pub instance_initiated_shutdown_behavior: Option<AttributeValue>,
pub instance_type: Option<AttributeValue>,
pub kernel_id: Option<AttributeValue>,
pub product_codes: Option<Vec<ProductCode>>,
pub ramdisk_id: Option<AttributeValue>,
pub root_device_name: Option<AttributeValue>,
pub source_dest_check: Option<AttributeBooleanValue>,
pub sriov_net_support: Option<AttributeValue>,
pub user_data: Option<AttributeValue>,
}
struct InstanceAttributeDeserializer;
impl InstanceAttributeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceAttribute, XmlParseError> {
deserialize_elements::<_, InstanceAttribute, _>(tag_name, stack, |name, stack, obj| {
match name {
"blockDeviceMapping" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
InstanceBlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMapping",
stack,
)?,
);
}
"disableApiTermination" => {
obj.disable_api_termination =
Some(AttributeBooleanValueDeserializer::deserialize(
"disableApiTermination",
stack,
)?);
}
"ebsOptimized" => {
obj.ebs_optimized = Some(AttributeBooleanValueDeserializer::deserialize(
"ebsOptimized",
stack,
)?);
}
"enaSupport" => {
obj.ena_support = Some(AttributeBooleanValueDeserializer::deserialize(
"enaSupport",
stack,
)?);
}
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceInitiatedShutdownBehavior" => {
obj.instance_initiated_shutdown_behavior =
Some(AttributeValueDeserializer::deserialize(
"instanceInitiatedShutdownBehavior",
stack,
)?);
}
"instanceType" => {
obj.instance_type = Some(AttributeValueDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"kernel" => {
obj.kernel_id = Some(AttributeValueDeserializer::deserialize("kernel", stack)?);
}
"productCodes" => {
obj.product_codes.get_or_insert(vec![]).extend(
ProductCodeListDeserializer::deserialize("productCodes", stack)?,
);
}
"ramdisk" => {
obj.ramdisk_id =
Some(AttributeValueDeserializer::deserialize("ramdisk", stack)?);
}
"rootDeviceName" => {
obj.root_device_name = Some(AttributeValueDeserializer::deserialize(
"rootDeviceName",
stack,
)?);
}
"sourceDestCheck" => {
obj.source_dest_check = Some(AttributeBooleanValueDeserializer::deserialize(
"sourceDestCheck",
stack,
)?);
}
"sriovNetSupport" => {
obj.sriov_net_support = Some(AttributeValueDeserializer::deserialize(
"sriovNetSupport",
stack,
)?);
}
"userData" => {
obj.user_data =
Some(AttributeValueDeserializer::deserialize("userData", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceBlockDeviceMapping {
pub device_name: Option<String>,
pub ebs: Option<EbsInstanceBlockDevice>,
}
struct InstanceBlockDeviceMappingDeserializer;
impl InstanceBlockDeviceMappingDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceBlockDeviceMapping, XmlParseError> {
deserialize_elements::<_, InstanceBlockDeviceMapping, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"deviceName" => {
obj.device_name =
Some(StringDeserializer::deserialize("deviceName", stack)?);
}
"ebs" => {
obj.ebs = Some(EbsInstanceBlockDeviceDeserializer::deserialize(
"ebs", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct InstanceBlockDeviceMappingListDeserializer;
impl InstanceBlockDeviceMappingListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceBlockDeviceMapping>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceBlockDeviceMappingDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceBlockDeviceMappingSpecification {
pub device_name: Option<String>,
pub ebs: Option<EbsInstanceBlockDeviceSpecification>,
pub no_device: Option<String>,
pub virtual_name: Option<String>,
}
struct InstanceBlockDeviceMappingSpecificationSerializer;
impl InstanceBlockDeviceMappingSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceBlockDeviceMappingSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.device_name {
params.put(&format!("{}{}", prefix, "DeviceName"), &field_value);
}
if let Some(ref field_value) = obj.ebs {
EbsInstanceBlockDeviceSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "Ebs"),
field_value,
);
}
if let Some(ref field_value) = obj.no_device {
params.put(&format!("{}{}", prefix, "NoDevice"), &field_value);
}
if let Some(ref field_value) = obj.virtual_name {
params.put(&format!("{}{}", prefix, "VirtualName"), &field_value);
}
}
}
struct InstanceBlockDeviceMappingSpecificationListSerializer;
impl InstanceBlockDeviceMappingSpecificationListSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<InstanceBlockDeviceMappingSpecification>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
InstanceBlockDeviceMappingSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceCapacity {
pub available_capacity: Option<i64>,
pub instance_type: Option<String>,
pub total_capacity: Option<i64>,
}
struct InstanceCapacityDeserializer;
impl InstanceCapacityDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceCapacity, XmlParseError> {
deserialize_elements::<_, InstanceCapacity, _>(tag_name, stack, |name, stack, obj| {
match name {
"availableCapacity" => {
obj.available_capacity = Some(IntegerDeserializer::deserialize(
"availableCapacity",
stack,
)?);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
"totalCapacity" => {
obj.total_capacity =
Some(IntegerDeserializer::deserialize("totalCapacity", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceCount {
pub instance_count: Option<i64>,
pub state: Option<String>,
}
struct InstanceCountDeserializer;
impl InstanceCountDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceCount, XmlParseError> {
deserialize_elements::<_, InstanceCount, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceCount" => {
obj.instance_count =
Some(IntegerDeserializer::deserialize("instanceCount", stack)?);
}
"state" => {
obj.state = Some(ListingStateDeserializer::deserialize("state", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceCountListDeserializer;
impl InstanceCountListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceCount>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceCountDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceCreditSpecification {
pub cpu_credits: Option<String>,
pub instance_id: Option<String>,
}
struct InstanceCreditSpecificationDeserializer;
impl InstanceCreditSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceCreditSpecification, XmlParseError> {
deserialize_elements::<_, InstanceCreditSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"cpuCredits" => {
obj.cpu_credits =
Some(StringDeserializer::deserialize("cpuCredits", stack)?);
}
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct InstanceCreditSpecificationListDeserializer;
impl InstanceCreditSpecificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceCreditSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceCreditSpecificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceCreditSpecificationListRequestSerializer;
impl InstanceCreditSpecificationListRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<InstanceCreditSpecificationRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
InstanceCreditSpecificationRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceCreditSpecificationRequest {
pub cpu_credits: Option<String>,
pub instance_id: Option<String>,
}
struct InstanceCreditSpecificationRequestSerializer;
impl InstanceCreditSpecificationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceCreditSpecificationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cpu_credits {
params.put(&format!("{}{}", prefix, "CpuCredits"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
}
}
struct InstanceEventIdDeserializer;
impl InstanceEventIdDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceExportDetails {
pub instance_id: Option<String>,
pub target_environment: Option<String>,
}
struct InstanceExportDetailsDeserializer;
impl InstanceExportDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceExportDetails, XmlParseError> {
deserialize_elements::<_, InstanceExportDetails, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"targetEnvironment" => {
obj.target_environment = Some(ExportEnvironmentDeserializer::deserialize(
"targetEnvironment",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceHealthStatusDeserializer;
impl InstanceHealthStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceIdDeserializer;
impl InstanceIdDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceIdSetDeserializer;
impl InstanceIdSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceIdStringListSerializer;
impl InstanceIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct InstanceIdsSetDeserializer;
impl InstanceIdsSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceIdDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceInterruptionBehaviorDeserializer;
impl InstanceInterruptionBehaviorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceIpv6Address {
pub ipv_6_address: Option<String>,
}
struct InstanceIpv6AddressDeserializer;
impl InstanceIpv6AddressDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceIpv6Address, XmlParseError> {
deserialize_elements::<_, InstanceIpv6Address, _>(tag_name, stack, |name, stack, obj| {
match name {
"ipv6Address" => {
obj.ipv_6_address =
Some(StringDeserializer::deserialize("ipv6Address", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceIpv6AddressSerializer;
impl InstanceIpv6AddressSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceIpv6Address) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.ipv_6_address {
params.put(&format!("{}{}", prefix, "Ipv6Address"), &field_value);
}
}
}
struct InstanceIpv6AddressListDeserializer;
impl InstanceIpv6AddressListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceIpv6Address>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceIpv6AddressDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceIpv6AddressListSerializer;
impl InstanceIpv6AddressListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<InstanceIpv6Address>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
InstanceIpv6AddressSerializer::serialize(params, &key, obj);
}
}
}
struct InstanceIpv6AddressListRequestSerializer;
impl InstanceIpv6AddressListRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<InstanceIpv6AddressRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
InstanceIpv6AddressRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceIpv6AddressRequest {
pub ipv_6_address: Option<String>,
}
struct InstanceIpv6AddressRequestSerializer;
impl InstanceIpv6AddressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceIpv6AddressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.ipv_6_address {
params.put(&format!("{}{}", prefix, "Ipv6Address"), &field_value);
}
}
}
struct InstanceLifecycleDeserializer;
impl InstanceLifecycleDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceLifecycleTypeDeserializer;
impl InstanceLifecycleTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceListDeserializer;
impl InstanceListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Instance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceMarketOptionsRequest {
pub market_type: Option<String>,
pub spot_options: Option<SpotMarketOptions>,
}
struct InstanceMarketOptionsRequestSerializer;
impl InstanceMarketOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceMarketOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.market_type {
params.put(&format!("{}{}", prefix, "MarketType"), &field_value);
}
if let Some(ref field_value) = obj.spot_options {
SpotMarketOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotOptions"),
field_value,
);
}
}
}
struct InstanceMatchCriteriaDeserializer;
impl InstanceMatchCriteriaDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceMonitoring {
pub instance_id: Option<String>,
pub monitoring: Option<Monitoring>,
}
struct InstanceMonitoringDeserializer;
impl InstanceMonitoringDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceMonitoring, XmlParseError> {
deserialize_elements::<_, InstanceMonitoring, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"monitoring" => {
obj.monitoring =
Some(MonitoringDeserializer::deserialize("monitoring", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceMonitoringListDeserializer;
impl InstanceMonitoringListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceMonitoring>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceMonitoringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceNetworkInterface {
pub association: Option<InstanceNetworkInterfaceAssociation>,
pub attachment: Option<InstanceNetworkInterfaceAttachment>,
pub description: Option<String>,
pub groups: Option<Vec<GroupIdentifier>>,
pub interface_type: Option<String>,
pub ipv_6_addresses: Option<Vec<InstanceIpv6Address>>,
pub mac_address: Option<String>,
pub network_interface_id: Option<String>,
pub owner_id: Option<String>,
pub private_dns_name: Option<String>,
pub private_ip_address: Option<String>,
pub private_ip_addresses: Option<Vec<InstancePrivateIpAddress>>,
pub source_dest_check: Option<bool>,
pub status: Option<String>,
pub subnet_id: Option<String>,
pub vpc_id: Option<String>,
}
struct InstanceNetworkInterfaceDeserializer;
impl InstanceNetworkInterfaceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceNetworkInterface, XmlParseError> {
deserialize_elements::<_, InstanceNetworkInterface, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"association" => {
obj.association = Some(
InstanceNetworkInterfaceAssociationDeserializer::deserialize(
"association",
stack,
)?,
);
}
"attachment" => {
obj.attachment =
Some(InstanceNetworkInterfaceAttachmentDeserializer::deserialize(
"attachment",
stack,
)?);
}
"description" => {
obj.description =
Some(StringDeserializer::deserialize("description", stack)?);
}
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"interfaceType" => {
obj.interface_type =
Some(StringDeserializer::deserialize("interfaceType", stack)?);
}
"ipv6AddressesSet" => {
obj.ipv_6_addresses.get_or_insert(vec![]).extend(
InstanceIpv6AddressListDeserializer::deserialize(
"ipv6AddressesSet",
stack,
)?,
);
}
"macAddress" => {
obj.mac_address =
Some(StringDeserializer::deserialize("macAddress", stack)?);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
"privateIpAddressesSet" => {
obj.private_ip_addresses.get_or_insert(vec![]).extend(
InstancePrivateIpAddressListDeserializer::deserialize(
"privateIpAddressesSet",
stack,
)?,
);
}
"sourceDestCheck" => {
obj.source_dest_check =
Some(BooleanDeserializer::deserialize("sourceDestCheck", stack)?);
}
"status" => {
obj.status = Some(NetworkInterfaceStatusDeserializer::deserialize(
"status", stack,
)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceNetworkInterfaceAssociation {
pub ip_owner_id: Option<String>,
pub public_dns_name: Option<String>,
pub public_ip: Option<String>,
}
struct InstanceNetworkInterfaceAssociationDeserializer;
impl InstanceNetworkInterfaceAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceNetworkInterfaceAssociation, XmlParseError> {
deserialize_elements::<_, InstanceNetworkInterfaceAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ipOwnerId" => {
obj.ip_owner_id =
Some(StringDeserializer::deserialize("ipOwnerId", stack)?);
}
"publicDnsName" => {
obj.public_dns_name =
Some(StringDeserializer::deserialize("publicDnsName", stack)?);
}
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceNetworkInterfaceAttachment {
pub attach_time: Option<String>,
pub attachment_id: Option<String>,
pub delete_on_termination: Option<bool>,
pub device_index: Option<i64>,
pub status: Option<String>,
}
struct InstanceNetworkInterfaceAttachmentDeserializer;
impl InstanceNetworkInterfaceAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceNetworkInterfaceAttachment, XmlParseError> {
deserialize_elements::<_, InstanceNetworkInterfaceAttachment, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"attachTime" => {
obj.attach_time =
Some(DateTimeDeserializer::deserialize("attachTime", stack)?);
}
"attachmentId" => {
obj.attachment_id =
Some(StringDeserializer::deserialize("attachmentId", stack)?);
}
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"deviceIndex" => {
obj.device_index =
Some(IntegerDeserializer::deserialize("deviceIndex", stack)?);
}
"status" => {
obj.status =
Some(AttachmentStatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct InstanceNetworkInterfaceListDeserializer;
impl InstanceNetworkInterfaceListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceNetworkInterface>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceNetworkInterfaceDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceNetworkInterfaceSpecification {
pub associate_public_ip_address: Option<bool>,
pub delete_on_termination: Option<bool>,
pub description: Option<String>,
pub device_index: Option<i64>,
pub groups: Option<Vec<String>>,
pub interface_type: Option<String>,
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<InstanceIpv6Address>>,
pub network_interface_id: Option<String>,
pub private_ip_address: Option<String>,
pub private_ip_addresses: Option<Vec<PrivateIpAddressSpecification>>,
pub secondary_private_ip_address_count: Option<i64>,
pub subnet_id: Option<String>,
}
struct InstanceNetworkInterfaceSpecificationDeserializer;
impl InstanceNetworkInterfaceSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceNetworkInterfaceSpecification, XmlParseError> {
deserialize_elements::<_, InstanceNetworkInterfaceSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associatePublicIpAddress" => {
obj.associate_public_ip_address = Some(BooleanDeserializer::deserialize(
"associatePublicIpAddress",
stack,
)?);
}
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"description" => {
obj.description =
Some(StringDeserializer::deserialize("description", stack)?);
}
"deviceIndex" => {
obj.device_index =
Some(IntegerDeserializer::deserialize("deviceIndex", stack)?);
}
"SecurityGroupId" => {
obj.groups.get_or_insert(vec![]).extend(
SecurityGroupIdStringListDeserializer::deserialize(
"SecurityGroupId",
stack,
)?,
);
}
"InterfaceType" => {
obj.interface_type =
Some(StringDeserializer::deserialize("InterfaceType", stack)?);
}
"ipv6AddressCount" => {
obj.ipv_6_address_count =
Some(IntegerDeserializer::deserialize("ipv6AddressCount", stack)?);
}
"ipv6AddressesSet" => {
obj.ipv_6_addresses.get_or_insert(vec![]).extend(
InstanceIpv6AddressListDeserializer::deserialize(
"ipv6AddressesSet",
stack,
)?,
);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
"privateIpAddressesSet" => {
obj.private_ip_addresses.get_or_insert(vec![]).extend(
PrivateIpAddressSpecificationListDeserializer::deserialize(
"privateIpAddressesSet",
stack,
)?,
);
}
"secondaryPrivateIpAddressCount" => {
obj.secondary_private_ip_address_count =
Some(IntegerDeserializer::deserialize(
"secondaryPrivateIpAddressCount",
stack,
)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct InstanceNetworkInterfaceSpecificationSerializer;
impl InstanceNetworkInterfaceSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceNetworkInterfaceSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.associate_public_ip_address {
params.put(
&format!("{}{}", prefix, "AssociatePublicIpAddress"),
&field_value,
);
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.device_index {
params.put(&format!("{}{}", prefix, "DeviceIndex"), &field_value);
}
if let Some(ref field_value) = obj.groups {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.interface_type {
params.put(&format!("{}{}", prefix, "InterfaceType"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_address_count {
params.put(&format!("{}{}", prefix, "Ipv6AddressCount"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_addresses {
InstanceIpv6AddressListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6AddressesSet"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interface_id {
params.put(&format!("{}{}", prefix, "NetworkInterfaceId"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_addresses {
PrivateIpAddressSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrivateIpAddressesSet"),
field_value,
);
}
if let Some(ref field_value) = obj.secondary_private_ip_address_count {
params.put(
&format!("{}{}", prefix, "SecondaryPrivateIpAddressCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
}
}
struct InstanceNetworkInterfaceSpecificationListDeserializer;
impl InstanceNetworkInterfaceSpecificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceNetworkInterfaceSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
InstanceNetworkInterfaceSpecificationDeserializer::deserialize("item", stack)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceNetworkInterfaceSpecificationListSerializer;
impl InstanceNetworkInterfaceSpecificationListSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<InstanceNetworkInterfaceSpecification>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
InstanceNetworkInterfaceSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstancePrivateIpAddress {
pub association: Option<InstanceNetworkInterfaceAssociation>,
pub primary: Option<bool>,
pub private_dns_name: Option<String>,
pub private_ip_address: Option<String>,
}
struct InstancePrivateIpAddressDeserializer;
impl InstancePrivateIpAddressDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstancePrivateIpAddress, XmlParseError> {
deserialize_elements::<_, InstancePrivateIpAddress, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"association" => {
obj.association = Some(
InstanceNetworkInterfaceAssociationDeserializer::deserialize(
"association",
stack,
)?,
);
}
"primary" => {
obj.primary = Some(BooleanDeserializer::deserialize("primary", stack)?);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct InstancePrivateIpAddressListDeserializer;
impl InstancePrivateIpAddressListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstancePrivateIpAddress>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstancePrivateIpAddressDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceSpecification {
pub exclude_boot_volume: Option<bool>,
pub instance_id: Option<String>,
}
struct InstanceSpecificationSerializer;
impl InstanceSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.exclude_boot_volume {
params.put(&format!("{}{}", prefix, "ExcludeBootVolume"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceState {
pub code: Option<i64>,
pub name: Option<String>,
}
struct InstanceStateDeserializer;
impl InstanceStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceState, XmlParseError> {
deserialize_elements::<_, InstanceState, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(IntegerDeserializer::deserialize("code", stack)?);
}
"name" => {
obj.name = Some(InstanceStateNameDeserializer::deserialize("name", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceStateChange {
pub current_state: Option<InstanceState>,
pub instance_id: Option<String>,
pub previous_state: Option<InstanceState>,
}
struct InstanceStateChangeDeserializer;
impl InstanceStateChangeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceStateChange, XmlParseError> {
deserialize_elements::<_, InstanceStateChange, _>(tag_name, stack, |name, stack, obj| {
match name {
"currentState" => {
obj.current_state = Some(InstanceStateDeserializer::deserialize(
"currentState",
stack,
)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"previousState" => {
obj.previous_state = Some(InstanceStateDeserializer::deserialize(
"previousState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceStateChangeListDeserializer;
impl InstanceStateChangeListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceStateChange>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceStateChangeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceStateNameDeserializer;
impl InstanceStateNameDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceStatus {
pub availability_zone: Option<String>,
pub events: Option<Vec<InstanceStatusEvent>>,
pub instance_id: Option<String>,
pub instance_state: Option<InstanceState>,
pub instance_status: Option<InstanceStatusSummary>,
pub system_status: Option<InstanceStatusSummary>,
}
struct InstanceStatusDeserializer;
impl InstanceStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceStatus, XmlParseError> {
deserialize_elements::<_, InstanceStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"eventsSet" => {
obj.events.get_or_insert(vec![]).extend(
InstanceStatusEventListDeserializer::deserialize("eventsSet", stack)?,
);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceState" => {
obj.instance_state = Some(InstanceStateDeserializer::deserialize(
"instanceState",
stack,
)?);
}
"instanceStatus" => {
obj.instance_status = Some(InstanceStatusSummaryDeserializer::deserialize(
"instanceStatus",
stack,
)?);
}
"systemStatus" => {
obj.system_status = Some(InstanceStatusSummaryDeserializer::deserialize(
"systemStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceStatusDetails {
pub impaired_since: Option<String>,
pub name: Option<String>,
pub status: Option<String>,
}
struct InstanceStatusDetailsDeserializer;
impl InstanceStatusDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceStatusDetails, XmlParseError> {
deserialize_elements::<_, InstanceStatusDetails, _>(tag_name, stack, |name, stack, obj| {
match name {
"impairedSince" => {
obj.impaired_since =
Some(DateTimeDeserializer::deserialize("impairedSince", stack)?);
}
"name" => {
obj.name = Some(StatusNameDeserializer::deserialize("name", stack)?);
}
"status" => {
obj.status = Some(StatusTypeDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceStatusDetailsListDeserializer;
impl InstanceStatusDetailsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceStatusDetails>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceStatusDetailsDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceStatusEvent {
pub code: Option<String>,
pub description: Option<String>,
pub instance_event_id: Option<String>,
pub not_after: Option<String>,
pub not_before: Option<String>,
pub not_before_deadline: Option<String>,
}
struct InstanceStatusEventDeserializer;
impl InstanceStatusEventDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceStatusEvent, XmlParseError> {
deserialize_elements::<_, InstanceStatusEvent, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(EventCodeDeserializer::deserialize("code", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"instanceEventId" => {
obj.instance_event_id = Some(InstanceEventIdDeserializer::deserialize(
"instanceEventId",
stack,
)?);
}
"notAfter" => {
obj.not_after = Some(DateTimeDeserializer::deserialize("notAfter", stack)?);
}
"notBefore" => {
obj.not_before = Some(DateTimeDeserializer::deserialize("notBefore", stack)?);
}
"notBeforeDeadline" => {
obj.not_before_deadline = Some(DateTimeDeserializer::deserialize(
"notBeforeDeadline",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceStatusEventListDeserializer;
impl InstanceStatusEventListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceStatusEvent>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceStatusEventDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InstanceStatusListDeserializer;
impl InstanceStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InstanceStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InstanceStatusDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceStatusSummary {
pub details: Option<Vec<InstanceStatusDetails>>,
pub status: Option<String>,
}
struct InstanceStatusSummaryDeserializer;
impl InstanceStatusSummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceStatusSummary, XmlParseError> {
deserialize_elements::<_, InstanceStatusSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"details" => {
obj.details.get_or_insert(vec![]).extend(
InstanceStatusDetailsListDeserializer::deserialize("details", stack)?,
);
}
"status" => {
obj.status = Some(SummaryStatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct InstanceTypeDeserializer;
impl InstanceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceTypeListSerializer;
impl InstanceTypeListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct IntegerDeserializer;
impl IntegerDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InterfacePermissionTypeDeserializer;
impl InterfacePermissionTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InternetGateway {
pub attachments: Option<Vec<InternetGatewayAttachment>>,
pub internet_gateway_id: Option<String>,
pub owner_id: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct InternetGatewayDeserializer;
impl InternetGatewayDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InternetGateway, XmlParseError> {
deserialize_elements::<_, InternetGateway, _>(tag_name, stack, |name, stack, obj| {
match name {
"attachmentSet" => {
obj.attachments.get_or_insert(vec![]).extend(
InternetGatewayAttachmentListDeserializer::deserialize(
"attachmentSet",
stack,
)?,
);
}
"internetGatewayId" => {
obj.internet_gateway_id =
Some(StringDeserializer::deserialize("internetGatewayId", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InternetGatewayAttachment {
pub state: Option<String>,
pub vpc_id: Option<String>,
}
struct InternetGatewayAttachmentDeserializer;
impl InternetGatewayAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InternetGatewayAttachment, XmlParseError> {
deserialize_elements::<_, InternetGatewayAttachment, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"state" => {
obj.state =
Some(AttachmentStatusDeserializer::deserialize("state", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct InternetGatewayAttachmentListDeserializer;
impl InternetGatewayAttachmentListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InternetGatewayAttachment>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InternetGatewayAttachmentDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InternetGatewayListDeserializer;
impl InternetGatewayListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InternetGateway>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(InternetGatewayDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IpPermission {
pub from_port: Option<i64>,
pub ip_protocol: Option<String>,
pub ip_ranges: Option<Vec<IpRange>>,
pub ipv_6_ranges: Option<Vec<Ipv6Range>>,
pub prefix_list_ids: Option<Vec<PrefixListId>>,
pub to_port: Option<i64>,
pub user_id_group_pairs: Option<Vec<UserIdGroupPair>>,
}
struct IpPermissionDeserializer;
impl IpPermissionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IpPermission, XmlParseError> {
deserialize_elements::<_, IpPermission, _>(tag_name, stack, |name, stack, obj| {
match name {
"fromPort" => {
obj.from_port = Some(IntegerDeserializer::deserialize("fromPort", stack)?);
}
"ipProtocol" => {
obj.ip_protocol = Some(StringDeserializer::deserialize("ipProtocol", stack)?);
}
"ipRanges" => {
obj.ip_ranges
.get_or_insert(vec![])
.extend(IpRangeListDeserializer::deserialize("ipRanges", stack)?);
}
"ipv6Ranges" => {
obj.ipv_6_ranges
.get_or_insert(vec![])
.extend(Ipv6RangeListDeserializer::deserialize("ipv6Ranges", stack)?);
}
"prefixListIds" => {
obj.prefix_list_ids.get_or_insert(vec![]).extend(
PrefixListIdListDeserializer::deserialize("prefixListIds", stack)?,
);
}
"toPort" => {
obj.to_port = Some(IntegerDeserializer::deserialize("toPort", stack)?);
}
"groups" => {
obj.user_id_group_pairs.get_or_insert(vec![]).extend(
UserIdGroupPairListDeserializer::deserialize("groups", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IpPermissionSerializer;
impl IpPermissionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IpPermission) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.from_port {
params.put(&format!("{}{}", prefix, "FromPort"), &field_value);
}
if let Some(ref field_value) = obj.ip_protocol {
params.put(&format!("{}{}", prefix, "IpProtocol"), &field_value);
}
if let Some(ref field_value) = obj.ip_ranges {
IpRangeListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpRanges"),
field_value,
);
}
if let Some(ref field_value) = obj.ipv_6_ranges {
Ipv6RangeListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Ranges"),
field_value,
);
}
if let Some(ref field_value) = obj.prefix_list_ids {
PrefixListIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrefixListIds"),
field_value,
);
}
if let Some(ref field_value) = obj.to_port {
params.put(&format!("{}{}", prefix, "ToPort"), &field_value);
}
if let Some(ref field_value) = obj.user_id_group_pairs {
UserIdGroupPairListSerializer::serialize(
params,
&format!("{}{}", prefix, "Groups"),
field_value,
);
}
}
}
struct IpPermissionListDeserializer;
impl IpPermissionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IpPermission>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(IpPermissionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct IpPermissionListSerializer;
impl IpPermissionListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<IpPermission>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
IpPermissionSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IpRange {
pub cidr_ip: Option<String>,
pub description: Option<String>,
}
struct IpRangeDeserializer;
impl IpRangeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IpRange, XmlParseError> {
deserialize_elements::<_, IpRange, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidrIp" => {
obj.cidr_ip = Some(StringDeserializer::deserialize("cidrIp", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IpRangeSerializer;
impl IpRangeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IpRange) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_ip {
params.put(&format!("{}{}", prefix, "CidrIp"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
}
}
struct IpRangeListDeserializer;
impl IpRangeListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IpRange>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(IpRangeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct IpRangeListSerializer;
impl IpRangeListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<IpRange>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
IpRangeSerializer::serialize(params, &key, obj);
}
}
}
struct IpRangesDeserializer;
impl IpRangesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct Ipv6AddressListDeserializer;
impl Ipv6AddressListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct Ipv6AddressListSerializer;
impl Ipv6AddressListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Ipv6CidrBlock {
pub ipv_6_cidr_block: Option<String>,
}
struct Ipv6CidrBlockDeserializer;
impl Ipv6CidrBlockDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Ipv6CidrBlock, XmlParseError> {
deserialize_elements::<_, Ipv6CidrBlock, _>(tag_name, stack, |name, stack, obj| {
match name {
"ipv6CidrBlock" => {
obj.ipv_6_cidr_block =
Some(StringDeserializer::deserialize("ipv6CidrBlock", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct Ipv6CidrBlockSetDeserializer;
impl Ipv6CidrBlockSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Ipv6CidrBlock>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(Ipv6CidrBlockDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Ipv6Range {
pub cidr_ipv_6: Option<String>,
pub description: Option<String>,
}
struct Ipv6RangeDeserializer;
impl Ipv6RangeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Ipv6Range, XmlParseError> {
deserialize_elements::<_, Ipv6Range, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidrIpv6" => {
obj.cidr_ipv_6 = Some(StringDeserializer::deserialize("cidrIpv6", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct Ipv6RangeSerializer;
impl Ipv6RangeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Ipv6Range) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_ipv_6 {
params.put(&format!("{}{}", prefix, "CidrIpv6"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
}
}
struct Ipv6RangeListDeserializer;
impl Ipv6RangeListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Ipv6Range>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(Ipv6RangeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct Ipv6RangeListSerializer;
impl Ipv6RangeListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Ipv6Range>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
Ipv6RangeSerializer::serialize(params, &key, obj);
}
}
}
struct Ipv6SupportValueDeserializer;
impl Ipv6SupportValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct KeyNameStringListSerializer;
impl KeyNameStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct KeyPair {
pub key_fingerprint: Option<String>,
pub key_material: Option<String>,
pub key_name: Option<String>,
}
struct KeyPairDeserializer;
impl KeyPairDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<KeyPair, XmlParseError> {
deserialize_elements::<_, KeyPair, _>(tag_name, stack, |name, stack, obj| {
match name {
"keyFingerprint" => {
obj.key_fingerprint =
Some(StringDeserializer::deserialize("keyFingerprint", stack)?);
}
"keyMaterial" => {
obj.key_material = Some(StringDeserializer::deserialize("keyMaterial", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct KeyPairInfo {
pub key_fingerprint: Option<String>,
pub key_name: Option<String>,
}
struct KeyPairInfoDeserializer;
impl KeyPairInfoDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<KeyPairInfo, XmlParseError> {
deserialize_elements::<_, KeyPairInfo, _>(tag_name, stack, |name, stack, obj| {
match name {
"keyFingerprint" => {
obj.key_fingerprint =
Some(StringDeserializer::deserialize("keyFingerprint", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct KeyPairListDeserializer;
impl KeyPairListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<KeyPairInfo>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(KeyPairInfoDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchPermission {
pub group: Option<String>,
pub user_id: Option<String>,
}
struct LaunchPermissionDeserializer;
impl LaunchPermissionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchPermission, XmlParseError> {
deserialize_elements::<_, LaunchPermission, _>(tag_name, stack, |name, stack, obj| {
match name {
"group" => {
obj.group = Some(PermissionGroupDeserializer::deserialize("group", stack)?);
}
"userId" => {
obj.user_id = Some(StringDeserializer::deserialize("userId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LaunchPermissionSerializer;
impl LaunchPermissionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchPermission) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.group {
params.put(&format!("{}{}", prefix, "Group"), &field_value);
}
if let Some(ref field_value) = obj.user_id {
params.put(&format!("{}{}", prefix, "UserId"), &field_value);
}
}
}
struct LaunchPermissionListDeserializer;
impl LaunchPermissionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchPermission>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchPermissionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LaunchPermissionListSerializer;
impl LaunchPermissionListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LaunchPermission>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchPermissionSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchPermissionModifications {
pub add: Option<Vec<LaunchPermission>>,
pub remove: Option<Vec<LaunchPermission>>,
}
struct LaunchPermissionModificationsSerializer;
impl LaunchPermissionModificationsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchPermissionModifications) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add {
LaunchPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "Add"),
field_value,
);
}
if let Some(ref field_value) = obj.remove {
LaunchPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "Remove"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchSpecification {
pub addressing_type: Option<String>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub ebs_optimized: Option<bool>,
pub iam_instance_profile: Option<IamInstanceProfileSpecification>,
pub image_id: Option<String>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub monitoring: Option<RunInstancesMonitoringEnabled>,
pub network_interfaces: Option<Vec<InstanceNetworkInterfaceSpecification>>,
pub placement: Option<SpotPlacement>,
pub ramdisk_id: Option<String>,
pub security_groups: Option<Vec<GroupIdentifier>>,
pub subnet_id: Option<String>,
pub user_data: Option<String>,
}
struct LaunchSpecificationDeserializer;
impl LaunchSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchSpecification, XmlParseError> {
deserialize_elements::<_, LaunchSpecification, _>(tag_name, stack, |name, stack, obj| {
match name {
"addressingType" => {
obj.addressing_type =
Some(StringDeserializer::deserialize("addressingType", stack)?);
}
"blockDeviceMapping" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
BlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMapping",
stack,
)?,
);
}
"ebsOptimized" => {
obj.ebs_optimized =
Some(BooleanDeserializer::deserialize("ebsOptimized", stack)?);
}
"iamInstanceProfile" => {
obj.iam_instance_profile =
Some(IamInstanceProfileSpecificationDeserializer::deserialize(
"iamInstanceProfile",
stack,
)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"kernelId" => {
obj.kernel_id = Some(StringDeserializer::deserialize("kernelId", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
"monitoring" => {
obj.monitoring = Some(RunInstancesMonitoringEnabledDeserializer::deserialize(
"monitoring",
stack,
)?);
}
"networkInterfaceSet" => {
obj.network_interfaces.get_or_insert(vec![]).extend(
InstanceNetworkInterfaceSpecificationListDeserializer::deserialize(
"networkInterfaceSet",
stack,
)?,
);
}
"placement" => {
obj.placement =
Some(SpotPlacementDeserializer::deserialize("placement", stack)?);
}
"ramdiskId" => {
obj.ramdisk_id = Some(StringDeserializer::deserialize("ramdiskId", stack)?);
}
"groupSet" => {
obj.security_groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"userData" => {
obj.user_data = Some(StringDeserializer::deserialize("userData", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LaunchSpecsListDeserializer;
impl LaunchSpecsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SpotFleetLaunchSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SpotFleetLaunchSpecificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LaunchSpecsListSerializer;
impl LaunchSpecsListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<SpotFleetLaunchSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
SpotFleetLaunchSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplate {
pub create_time: Option<String>,
pub created_by: Option<String>,
pub default_version_number: Option<i64>,
pub latest_version_number: Option<i64>,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct LaunchTemplateDeserializer;
impl LaunchTemplateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplate, XmlParseError> {
deserialize_elements::<_, LaunchTemplate, _>(tag_name, stack, |name, stack, obj| {
match name {
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"createdBy" => {
obj.created_by = Some(StringDeserializer::deserialize("createdBy", stack)?);
}
"defaultVersionNumber" => {
obj.default_version_number = Some(LongDeserializer::deserialize(
"defaultVersionNumber",
stack,
)?);
}
"latestVersionNumber" => {
obj.latest_version_number =
Some(LongDeserializer::deserialize("latestVersionNumber", stack)?);
}
"launchTemplateId" => {
obj.launch_template_id =
Some(StringDeserializer::deserialize("launchTemplateId", stack)?);
}
"launchTemplateName" => {
obj.launch_template_name = Some(LaunchTemplateNameDeserializer::deserialize(
"launchTemplateName",
stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateAndOverridesResponse {
pub launch_template_specification: Option<FleetLaunchTemplateSpecification>,
pub overrides: Option<FleetLaunchTemplateOverrides>,
}
struct LaunchTemplateAndOverridesResponseDeserializer;
impl LaunchTemplateAndOverridesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateAndOverridesResponse, XmlParseError> {
deserialize_elements::<_, LaunchTemplateAndOverridesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplateSpecification" => {
obj.launch_template_specification =
Some(FleetLaunchTemplateSpecificationDeserializer::deserialize(
"launchTemplateSpecification",
stack,
)?);
}
"overrides" => {
obj.overrides =
Some(FleetLaunchTemplateOverridesDeserializer::deserialize(
"overrides",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateBlockDeviceMapping {
pub device_name: Option<String>,
pub ebs: Option<LaunchTemplateEbsBlockDevice>,
pub no_device: Option<String>,
pub virtual_name: Option<String>,
}
struct LaunchTemplateBlockDeviceMappingDeserializer;
impl LaunchTemplateBlockDeviceMappingDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateBlockDeviceMapping, XmlParseError> {
deserialize_elements::<_, LaunchTemplateBlockDeviceMapping, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"deviceName" => {
obj.device_name =
Some(StringDeserializer::deserialize("deviceName", stack)?);
}
"ebs" => {
obj.ebs = Some(LaunchTemplateEbsBlockDeviceDeserializer::deserialize(
"ebs", stack,
)?);
}
"noDevice" => {
obj.no_device = Some(StringDeserializer::deserialize("noDevice", stack)?);
}
"virtualName" => {
obj.virtual_name =
Some(StringDeserializer::deserialize("virtualName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct LaunchTemplateBlockDeviceMappingListDeserializer;
impl LaunchTemplateBlockDeviceMappingListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateBlockDeviceMapping>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateBlockDeviceMappingDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateBlockDeviceMappingRequest {
pub device_name: Option<String>,
pub ebs: Option<LaunchTemplateEbsBlockDeviceRequest>,
pub no_device: Option<String>,
pub virtual_name: Option<String>,
}
struct LaunchTemplateBlockDeviceMappingRequestSerializer;
impl LaunchTemplateBlockDeviceMappingRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateBlockDeviceMappingRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.device_name {
params.put(&format!("{}{}", prefix, "DeviceName"), &field_value);
}
if let Some(ref field_value) = obj.ebs {
LaunchTemplateEbsBlockDeviceRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Ebs"),
field_value,
);
}
if let Some(ref field_value) = obj.no_device {
params.put(&format!("{}{}", prefix, "NoDevice"), &field_value);
}
if let Some(ref field_value) = obj.virtual_name {
params.put(&format!("{}{}", prefix, "VirtualName"), &field_value);
}
}
}
struct LaunchTemplateBlockDeviceMappingRequestListSerializer;
impl LaunchTemplateBlockDeviceMappingRequestListSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<LaunchTemplateBlockDeviceMappingRequest>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateBlockDeviceMappingRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateCapacityReservationSpecificationRequest {
pub capacity_reservation_preference: Option<String>,
pub capacity_reservation_target: Option<CapacityReservationTarget>,
}
struct LaunchTemplateCapacityReservationSpecificationRequestSerializer;
impl LaunchTemplateCapacityReservationSpecificationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &LaunchTemplateCapacityReservationSpecificationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capacity_reservation_preference {
params.put(
&format!("{}{}", prefix, "CapacityReservationPreference"),
&field_value,
);
}
if let Some(ref field_value) = obj.capacity_reservation_target {
CapacityReservationTargetSerializer::serialize(
params,
&format!("{}{}", prefix, "CapacityReservationTarget"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateCapacityReservationSpecificationResponse {
pub capacity_reservation_preference: Option<String>,
pub capacity_reservation_target: Option<CapacityReservationTargetResponse>,
}
struct LaunchTemplateCapacityReservationSpecificationResponseDeserializer;
impl LaunchTemplateCapacityReservationSpecificationResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateCapacityReservationSpecificationResponse, XmlParseError> {
deserialize_elements::<_, LaunchTemplateCapacityReservationSpecificationResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"capacityReservationPreference" => {
obj.capacity_reservation_preference =
Some(CapacityReservationPreferenceDeserializer::deserialize(
"capacityReservationPreference",
stack,
)?);
}
"capacityReservationTarget" => {
obj.capacity_reservation_target =
Some(CapacityReservationTargetResponseDeserializer::deserialize(
"capacityReservationTarget",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateConfig {
pub launch_template_specification: Option<FleetLaunchTemplateSpecification>,
pub overrides: Option<Vec<LaunchTemplateOverrides>>,
}
struct LaunchTemplateConfigDeserializer;
impl LaunchTemplateConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateConfig, XmlParseError> {
deserialize_elements::<_, LaunchTemplateConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"launchTemplateSpecification" => {
obj.launch_template_specification =
Some(FleetLaunchTemplateSpecificationDeserializer::deserialize(
"launchTemplateSpecification",
stack,
)?);
}
"overrides" => {
obj.overrides.get_or_insert(vec![]).extend(
LaunchTemplateOverridesListDeserializer::deserialize("overrides", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LaunchTemplateConfigSerializer;
impl LaunchTemplateConfigSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateConfig) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_specification {
FleetLaunchTemplateSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.overrides {
LaunchTemplateOverridesListSerializer::serialize(
params,
&format!("{}{}", prefix, "Overrides"),
field_value,
);
}
}
}
struct LaunchTemplateConfigListDeserializer;
impl LaunchTemplateConfigListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateConfig>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateConfigDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LaunchTemplateConfigListSerializer;
impl LaunchTemplateConfigListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LaunchTemplateConfig>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateConfigSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateCpuOptions {
pub core_count: Option<i64>,
pub threads_per_core: Option<i64>,
}
struct LaunchTemplateCpuOptionsDeserializer;
impl LaunchTemplateCpuOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateCpuOptions, XmlParseError> {
deserialize_elements::<_, LaunchTemplateCpuOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"coreCount" => {
obj.core_count =
Some(IntegerDeserializer::deserialize("coreCount", stack)?);
}
"threadsPerCore" => {
obj.threads_per_core =
Some(IntegerDeserializer::deserialize("threadsPerCore", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateCpuOptionsRequest {
pub core_count: Option<i64>,
pub threads_per_core: Option<i64>,
}
struct LaunchTemplateCpuOptionsRequestSerializer;
impl LaunchTemplateCpuOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateCpuOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.core_count {
params.put(&format!("{}{}", prefix, "CoreCount"), &field_value);
}
if let Some(ref field_value) = obj.threads_per_core {
params.put(&format!("{}{}", prefix, "ThreadsPerCore"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateEbsBlockDevice {
pub delete_on_termination: Option<bool>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub snapshot_id: Option<String>,
pub volume_size: Option<i64>,
pub volume_type: Option<String>,
}
struct LaunchTemplateEbsBlockDeviceDeserializer;
impl LaunchTemplateEbsBlockDeviceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateEbsBlockDevice, XmlParseError> {
deserialize_elements::<_, LaunchTemplateEbsBlockDevice, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"iops" => {
obj.iops = Some(IntegerDeserializer::deserialize("iops", stack)?);
}
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
"snapshotId" => {
obj.snapshot_id =
Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"volumeSize" => {
obj.volume_size =
Some(IntegerDeserializer::deserialize("volumeSize", stack)?);
}
"volumeType" => {
obj.volume_type =
Some(VolumeTypeDeserializer::deserialize("volumeType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateEbsBlockDeviceRequest {
pub delete_on_termination: Option<bool>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub snapshot_id: Option<String>,
pub volume_size: Option<i64>,
pub volume_type: Option<String>,
}
struct LaunchTemplateEbsBlockDeviceRequestSerializer;
impl LaunchTemplateEbsBlockDeviceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateEbsBlockDeviceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_id {
params.put(&format!("{}{}", prefix, "SnapshotId"), &field_value);
}
if let Some(ref field_value) = obj.volume_size {
params.put(&format!("{}{}", prefix, "VolumeSize"), &field_value);
}
if let Some(ref field_value) = obj.volume_type {
params.put(&format!("{}{}", prefix, "VolumeType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateElasticInferenceAccelerator {
pub type_: String,
}
struct LaunchTemplateElasticInferenceAcceleratorSerializer;
impl LaunchTemplateElasticInferenceAcceleratorSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateElasticInferenceAccelerator) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
}
}
struct LaunchTemplateElasticInferenceAcceleratorListSerializer;
impl LaunchTemplateElasticInferenceAcceleratorListSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<LaunchTemplateElasticInferenceAccelerator>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateElasticInferenceAcceleratorSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateElasticInferenceAcceleratorResponse {
pub type_: Option<String>,
}
struct LaunchTemplateElasticInferenceAcceleratorResponseDeserializer;
impl LaunchTemplateElasticInferenceAcceleratorResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateElasticInferenceAcceleratorResponse, XmlParseError> {
deserialize_elements::<_, LaunchTemplateElasticInferenceAcceleratorResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"type" => {
obj.type_ = Some(StringDeserializer::deserialize("type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct LaunchTemplateElasticInferenceAcceleratorResponseListDeserializer;
impl LaunchTemplateElasticInferenceAcceleratorResponseListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateElasticInferenceAcceleratorResponse>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
LaunchTemplateElasticInferenceAcceleratorResponseDeserializer::deserialize(
"item", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LaunchTemplateErrorCodeDeserializer;
impl LaunchTemplateErrorCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateHibernationOptions {
pub configured: Option<bool>,
}
struct LaunchTemplateHibernationOptionsDeserializer;
impl LaunchTemplateHibernationOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateHibernationOptions, XmlParseError> {
deserialize_elements::<_, LaunchTemplateHibernationOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"configured" => {
obj.configured =
Some(BooleanDeserializer::deserialize("configured", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateHibernationOptionsRequest {
pub configured: Option<bool>,
}
struct LaunchTemplateHibernationOptionsRequestSerializer;
impl LaunchTemplateHibernationOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateHibernationOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.configured {
params.put(&format!("{}{}", prefix, "Configured"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateIamInstanceProfileSpecification {
pub arn: Option<String>,
pub name: Option<String>,
}
struct LaunchTemplateIamInstanceProfileSpecificationDeserializer;
impl LaunchTemplateIamInstanceProfileSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateIamInstanceProfileSpecification, XmlParseError> {
deserialize_elements::<_, LaunchTemplateIamInstanceProfileSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"arn" => {
obj.arn = Some(StringDeserializer::deserialize("arn", stack)?);
}
"name" => {
obj.name = Some(StringDeserializer::deserialize("name", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateIamInstanceProfileSpecificationRequest {
pub arn: Option<String>,
pub name: Option<String>,
}
struct LaunchTemplateIamInstanceProfileSpecificationRequestSerializer;
impl LaunchTemplateIamInstanceProfileSpecificationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &LaunchTemplateIamInstanceProfileSpecificationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.arn {
params.put(&format!("{}{}", prefix, "Arn"), &field_value);
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateInstanceMarketOptions {
pub market_type: Option<String>,
pub spot_options: Option<LaunchTemplateSpotMarketOptions>,
}
struct LaunchTemplateInstanceMarketOptionsDeserializer;
impl LaunchTemplateInstanceMarketOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateInstanceMarketOptions, XmlParseError> {
deserialize_elements::<_, LaunchTemplateInstanceMarketOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"marketType" => {
obj.market_type =
Some(MarketTypeDeserializer::deserialize("marketType", stack)?);
}
"spotOptions" => {
obj.spot_options =
Some(LaunchTemplateSpotMarketOptionsDeserializer::deserialize(
"spotOptions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateInstanceMarketOptionsRequest {
pub market_type: Option<String>,
pub spot_options: Option<LaunchTemplateSpotMarketOptionsRequest>,
}
struct LaunchTemplateInstanceMarketOptionsRequestSerializer;
impl LaunchTemplateInstanceMarketOptionsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &LaunchTemplateInstanceMarketOptionsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.market_type {
params.put(&format!("{}{}", prefix, "MarketType"), &field_value);
}
if let Some(ref field_value) = obj.spot_options {
LaunchTemplateSpotMarketOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotOptions"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateInstanceNetworkInterfaceSpecification {
pub associate_public_ip_address: Option<bool>,
pub delete_on_termination: Option<bool>,
pub description: Option<String>,
pub device_index: Option<i64>,
pub groups: Option<Vec<String>>,
pub interface_type: Option<String>,
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<InstanceIpv6Address>>,
pub network_interface_id: Option<String>,
pub private_ip_address: Option<String>,
pub private_ip_addresses: Option<Vec<PrivateIpAddressSpecification>>,
pub secondary_private_ip_address_count: Option<i64>,
pub subnet_id: Option<String>,
}
struct LaunchTemplateInstanceNetworkInterfaceSpecificationDeserializer;
impl LaunchTemplateInstanceNetworkInterfaceSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateInstanceNetworkInterfaceSpecification, XmlParseError> {
deserialize_elements::<_, LaunchTemplateInstanceNetworkInterfaceSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associatePublicIpAddress" => {
obj.associate_public_ip_address = Some(BooleanDeserializer::deserialize(
"associatePublicIpAddress",
stack,
)?);
}
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"description" => {
obj.description =
Some(StringDeserializer::deserialize("description", stack)?);
}
"deviceIndex" => {
obj.device_index =
Some(IntegerDeserializer::deserialize("deviceIndex", stack)?);
}
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdStringListDeserializer::deserialize("groupSet", stack)?,
);
}
"interfaceType" => {
obj.interface_type =
Some(StringDeserializer::deserialize("interfaceType", stack)?);
}
"ipv6AddressCount" => {
obj.ipv_6_address_count =
Some(IntegerDeserializer::deserialize("ipv6AddressCount", stack)?);
}
"ipv6AddressesSet" => {
obj.ipv_6_addresses.get_or_insert(vec![]).extend(
InstanceIpv6AddressListDeserializer::deserialize(
"ipv6AddressesSet",
stack,
)?,
);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
"privateIpAddressesSet" => {
obj.private_ip_addresses.get_or_insert(vec![]).extend(
PrivateIpAddressSpecificationListDeserializer::deserialize(
"privateIpAddressesSet",
stack,
)?,
);
}
"secondaryPrivateIpAddressCount" => {
obj.secondary_private_ip_address_count =
Some(IntegerDeserializer::deserialize(
"secondaryPrivateIpAddressCount",
stack,
)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct LaunchTemplateInstanceNetworkInterfaceSpecificationListDeserializer;
impl LaunchTemplateInstanceNetworkInterfaceSpecificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateInstanceNetworkInterfaceSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
LaunchTemplateInstanceNetworkInterfaceSpecificationDeserializer::deserialize(
"item", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateInstanceNetworkInterfaceSpecificationRequest {
pub associate_public_ip_address: Option<bool>,
pub delete_on_termination: Option<bool>,
pub description: Option<String>,
pub device_index: Option<i64>,
pub groups: Option<Vec<String>>,
pub interface_type: Option<String>,
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<InstanceIpv6AddressRequest>>,
pub network_interface_id: Option<String>,
pub private_ip_address: Option<String>,
pub private_ip_addresses: Option<Vec<PrivateIpAddressSpecification>>,
pub secondary_private_ip_address_count: Option<i64>,
pub subnet_id: Option<String>,
}
struct LaunchTemplateInstanceNetworkInterfaceSpecificationRequestSerializer;
impl LaunchTemplateInstanceNetworkInterfaceSpecificationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &LaunchTemplateInstanceNetworkInterfaceSpecificationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.associate_public_ip_address {
params.put(
&format!("{}{}", prefix, "AssociatePublicIpAddress"),
&field_value,
);
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.device_index {
params.put(&format!("{}{}", prefix, "DeviceIndex"), &field_value);
}
if let Some(ref field_value) = obj.groups {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.interface_type {
params.put(&format!("{}{}", prefix, "InterfaceType"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_address_count {
params.put(&format!("{}{}", prefix, "Ipv6AddressCount"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_addresses {
InstanceIpv6AddressListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Addresses"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interface_id {
params.put(&format!("{}{}", prefix, "NetworkInterfaceId"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_addresses {
PrivateIpAddressSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrivateIpAddresses"),
field_value,
);
}
if let Some(ref field_value) = obj.secondary_private_ip_address_count {
params.put(
&format!("{}{}", prefix, "SecondaryPrivateIpAddressCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
}
}
struct LaunchTemplateInstanceNetworkInterfaceSpecificationRequestListSerializer;
impl LaunchTemplateInstanceNetworkInterfaceSpecificationRequestListSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<LaunchTemplateInstanceNetworkInterfaceSpecificationRequest>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateInstanceNetworkInterfaceSpecificationRequestSerializer::serialize(
params, &key, obj,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateLicenseConfiguration {
pub license_configuration_arn: Option<String>,
}
struct LaunchTemplateLicenseConfigurationDeserializer;
impl LaunchTemplateLicenseConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateLicenseConfiguration, XmlParseError> {
deserialize_elements::<_, LaunchTemplateLicenseConfiguration, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"licenseConfigurationArn" => {
obj.license_configuration_arn = Some(StringDeserializer::deserialize(
"licenseConfigurationArn",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateLicenseConfigurationRequest {
pub license_configuration_arn: Option<String>,
}
struct LaunchTemplateLicenseConfigurationRequestSerializer;
impl LaunchTemplateLicenseConfigurationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateLicenseConfigurationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.license_configuration_arn {
params.put(
&format!("{}{}", prefix, "LicenseConfigurationArn"),
&field_value,
);
}
}
}
struct LaunchTemplateLicenseListDeserializer;
impl LaunchTemplateLicenseListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateLicenseConfiguration>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateLicenseConfigurationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LaunchTemplateLicenseSpecificationListRequestSerializer;
impl LaunchTemplateLicenseSpecificationListRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<LaunchTemplateLicenseConfigurationRequest>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateLicenseConfigurationRequestSerializer::serialize(params, &key, obj);
}
}
}
struct LaunchTemplateNameDeserializer;
impl LaunchTemplateNameDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LaunchTemplateNameStringListSerializer;
impl LaunchTemplateNameStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateOverrides {
pub availability_zone: Option<String>,
pub instance_type: Option<String>,
pub priority: Option<f64>,
pub spot_price: Option<String>,
pub subnet_id: Option<String>,
pub weighted_capacity: Option<f64>,
}
struct LaunchTemplateOverridesDeserializer;
impl LaunchTemplateOverridesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateOverrides, XmlParseError> {
deserialize_elements::<_, LaunchTemplateOverrides, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"priority" => {
obj.priority = Some(DoubleDeserializer::deserialize("priority", stack)?);
}
"spotPrice" => {
obj.spot_price = Some(StringDeserializer::deserialize("spotPrice", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"weightedCapacity" => {
obj.weighted_capacity =
Some(DoubleDeserializer::deserialize("weightedCapacity", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct LaunchTemplateOverridesSerializer;
impl LaunchTemplateOverridesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateOverrides) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.priority {
params.put(&format!("{}{}", prefix, "Priority"), &field_value);
}
if let Some(ref field_value) = obj.spot_price {
params.put(&format!("{}{}", prefix, "SpotPrice"), &field_value);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.weighted_capacity {
params.put(&format!("{}{}", prefix, "WeightedCapacity"), &field_value);
}
}
}
struct LaunchTemplateOverridesListDeserializer;
impl LaunchTemplateOverridesListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateOverrides>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateOverridesDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LaunchTemplateOverridesListSerializer;
impl LaunchTemplateOverridesListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LaunchTemplateOverrides>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateOverridesSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplatePlacement {
pub affinity: Option<String>,
pub availability_zone: Option<String>,
pub group_name: Option<String>,
pub host_id: Option<String>,
pub spread_domain: Option<String>,
pub tenancy: Option<String>,
}
struct LaunchTemplatePlacementDeserializer;
impl LaunchTemplatePlacementDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplatePlacement, XmlParseError> {
deserialize_elements::<_, LaunchTemplatePlacement, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"affinity" => {
obj.affinity = Some(StringDeserializer::deserialize("affinity", stack)?);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"hostId" => {
obj.host_id = Some(StringDeserializer::deserialize("hostId", stack)?);
}
"spreadDomain" => {
obj.spread_domain =
Some(StringDeserializer::deserialize("spreadDomain", stack)?);
}
"tenancy" => {
obj.tenancy = Some(TenancyDeserializer::deserialize("tenancy", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplatePlacementRequest {
pub affinity: Option<String>,
pub availability_zone: Option<String>,
pub group_name: Option<String>,
pub host_id: Option<String>,
pub spread_domain: Option<String>,
pub tenancy: Option<String>,
}
struct LaunchTemplatePlacementRequestSerializer;
impl LaunchTemplatePlacementRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplatePlacementRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.affinity {
params.put(&format!("{}{}", prefix, "Affinity"), &field_value);
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.host_id {
params.put(&format!("{}{}", prefix, "HostId"), &field_value);
}
if let Some(ref field_value) = obj.spread_domain {
params.put(&format!("{}{}", prefix, "SpreadDomain"), &field_value);
}
if let Some(ref field_value) = obj.tenancy {
params.put(&format!("{}{}", prefix, "Tenancy"), &field_value);
}
}
}
struct LaunchTemplateSetDeserializer;
impl LaunchTemplateSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplate>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateSpecification {
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub version: Option<String>,
}
struct LaunchTemplateSpecificationSerializer;
impl LaunchTemplateSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
if let Some(ref field_value) = obj.version {
params.put(&format!("{}{}", prefix, "Version"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateSpotMarketOptions {
pub block_duration_minutes: Option<i64>,
pub instance_interruption_behavior: Option<String>,
pub max_price: Option<String>,
pub spot_instance_type: Option<String>,
pub valid_until: Option<String>,
}
struct LaunchTemplateSpotMarketOptionsDeserializer;
impl LaunchTemplateSpotMarketOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateSpotMarketOptions, XmlParseError> {
deserialize_elements::<_, LaunchTemplateSpotMarketOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"blockDurationMinutes" => {
obj.block_duration_minutes = Some(IntegerDeserializer::deserialize(
"blockDurationMinutes",
stack,
)?);
}
"instanceInterruptionBehavior" => {
obj.instance_interruption_behavior =
Some(InstanceInterruptionBehaviorDeserializer::deserialize(
"instanceInterruptionBehavior",
stack,
)?);
}
"maxPrice" => {
obj.max_price = Some(StringDeserializer::deserialize("maxPrice", stack)?);
}
"spotInstanceType" => {
obj.spot_instance_type = Some(SpotInstanceTypeDeserializer::deserialize(
"spotInstanceType",
stack,
)?);
}
"validUntil" => {
obj.valid_until =
Some(DateTimeDeserializer::deserialize("validUntil", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateSpotMarketOptionsRequest {
pub block_duration_minutes: Option<i64>,
pub instance_interruption_behavior: Option<String>,
pub max_price: Option<String>,
pub spot_instance_type: Option<String>,
pub valid_until: Option<String>,
}
struct LaunchTemplateSpotMarketOptionsRequestSerializer;
impl LaunchTemplateSpotMarketOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateSpotMarketOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.block_duration_minutes {
params.put(
&format!("{}{}", prefix, "BlockDurationMinutes"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_interruption_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInterruptionBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.max_price {
params.put(&format!("{}{}", prefix, "MaxPrice"), &field_value);
}
if let Some(ref field_value) = obj.spot_instance_type {
params.put(&format!("{}{}", prefix, "SpotInstanceType"), &field_value);
}
if let Some(ref field_value) = obj.valid_until {
params.put(&format!("{}{}", prefix, "ValidUntil"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateTagSpecification {
pub resource_type: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct LaunchTemplateTagSpecificationDeserializer;
impl LaunchTemplateTagSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateTagSpecification, XmlParseError> {
deserialize_elements::<_, LaunchTemplateTagSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceType" => {
obj.resource_type = Some(ResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct LaunchTemplateTagSpecificationListDeserializer;
impl LaunchTemplateTagSpecificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateTagSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateTagSpecificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateTagSpecificationRequest {
pub resource_type: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct LaunchTemplateTagSpecificationRequestSerializer;
impl LaunchTemplateTagSpecificationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateTagSpecificationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.resource_type {
params.put(&format!("{}{}", prefix, "ResourceType"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
struct LaunchTemplateTagSpecificationRequestListSerializer;
impl LaunchTemplateTagSpecificationRequestListSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<LaunchTemplateTagSpecificationRequest>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LaunchTemplateTagSpecificationRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateVersion {
pub create_time: Option<String>,
pub created_by: Option<String>,
pub default_version: Option<bool>,
pub launch_template_data: Option<ResponseLaunchTemplateData>,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub version_description: Option<String>,
pub version_number: Option<i64>,
}
struct LaunchTemplateVersionDeserializer;
impl LaunchTemplateVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateVersion, XmlParseError> {
deserialize_elements::<_, LaunchTemplateVersion, _>(tag_name, stack, |name, stack, obj| {
match name {
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"createdBy" => {
obj.created_by = Some(StringDeserializer::deserialize("createdBy", stack)?);
}
"defaultVersion" => {
obj.default_version =
Some(BooleanDeserializer::deserialize("defaultVersion", stack)?);
}
"launchTemplateData" => {
obj.launch_template_data =
Some(ResponseLaunchTemplateDataDeserializer::deserialize(
"launchTemplateData",
stack,
)?);
}
"launchTemplateId" => {
obj.launch_template_id =
Some(StringDeserializer::deserialize("launchTemplateId", stack)?);
}
"launchTemplateName" => {
obj.launch_template_name = Some(LaunchTemplateNameDeserializer::deserialize(
"launchTemplateName",
stack,
)?);
}
"versionDescription" => {
obj.version_description = Some(VersionDescriptionDeserializer::deserialize(
"versionDescription",
stack,
)?);
}
"versionNumber" => {
obj.version_number =
Some(LongDeserializer::deserialize("versionNumber", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LaunchTemplateVersionSetDeserializer;
impl LaunchTemplateVersionSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateVersion>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LaunchTemplateVersionDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplatesMonitoring {
pub enabled: Option<bool>,
}
struct LaunchTemplatesMonitoringDeserializer;
impl LaunchTemplatesMonitoringDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplatesMonitoring, XmlParseError> {
deserialize_elements::<_, LaunchTemplatesMonitoring, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"enabled" => {
obj.enabled = Some(BooleanDeserializer::deserialize("enabled", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplatesMonitoringRequest {
pub enabled: Option<bool>,
}
struct LaunchTemplatesMonitoringRequestSerializer;
impl LaunchTemplatesMonitoringRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplatesMonitoringRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LicenseConfiguration {
pub license_configuration_arn: Option<String>,
}
struct LicenseConfigurationDeserializer;
impl LicenseConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LicenseConfiguration, XmlParseError> {
deserialize_elements::<_, LicenseConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"licenseConfigurationArn" => {
obj.license_configuration_arn = Some(StringDeserializer::deserialize(
"licenseConfigurationArn",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LicenseConfigurationRequest {
pub license_configuration_arn: Option<String>,
}
struct LicenseConfigurationRequestSerializer;
impl LicenseConfigurationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LicenseConfigurationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.license_configuration_arn {
params.put(
&format!("{}{}", prefix, "LicenseConfigurationArn"),
&field_value,
);
}
}
}
struct LicenseListDeserializer;
impl LicenseListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LicenseConfiguration>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LicenseConfigurationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LicenseSpecificationListRequestSerializer;
impl LicenseSpecificationListRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LicenseConfigurationRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LicenseConfigurationRequestSerializer::serialize(params, &key, obj);
}
}
}
struct ListingStateDeserializer;
impl ListingStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ListingStatusDeserializer;
impl ListingStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LoadBalancersConfig {
pub classic_load_balancers_config: Option<ClassicLoadBalancersConfig>,
pub target_groups_config: Option<TargetGroupsConfig>,
}
struct LoadBalancersConfigDeserializer;
impl LoadBalancersConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoadBalancersConfig, XmlParseError> {
deserialize_elements::<_, LoadBalancersConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"classicLoadBalancersConfig" => {
obj.classic_load_balancers_config =
Some(ClassicLoadBalancersConfigDeserializer::deserialize(
"classicLoadBalancersConfig",
stack,
)?);
}
"targetGroupsConfig" => {
obj.target_groups_config = Some(TargetGroupsConfigDeserializer::deserialize(
"targetGroupsConfig",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LoadBalancersConfigSerializer;
impl LoadBalancersConfigSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LoadBalancersConfig) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.classic_load_balancers_config {
ClassicLoadBalancersConfigSerializer::serialize(
params,
&format!("{}{}", prefix, "ClassicLoadBalancersConfig"),
field_value,
);
}
if let Some(ref field_value) = obj.target_groups_config {
TargetGroupsConfigSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetGroupsConfig"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LoadPermission {
pub group: Option<String>,
pub user_id: Option<String>,
}
struct LoadPermissionDeserializer;
impl LoadPermissionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoadPermission, XmlParseError> {
deserialize_elements::<_, LoadPermission, _>(tag_name, stack, |name, stack, obj| {
match name {
"group" => {
obj.group = Some(PermissionGroupDeserializer::deserialize("group", stack)?);
}
"userId" => {
obj.user_id = Some(StringDeserializer::deserialize("userId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LoadPermissionListDeserializer;
impl LoadPermissionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LoadPermission>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(LoadPermissionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LoadPermissionListRequestSerializer;
impl LoadPermissionListRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LoadPermissionRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
LoadPermissionRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LoadPermissionModifications {
pub add: Option<Vec<LoadPermissionRequest>>,
pub remove: Option<Vec<LoadPermissionRequest>>,
}
struct LoadPermissionModificationsSerializer;
impl LoadPermissionModificationsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LoadPermissionModifications) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add {
LoadPermissionListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Add"),
field_value,
);
}
if let Some(ref field_value) = obj.remove {
LoadPermissionListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Remove"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LoadPermissionRequest {
pub group: Option<String>,
pub user_id: Option<String>,
}
struct LoadPermissionRequestSerializer;
impl LoadPermissionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LoadPermissionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.group {
params.put(&format!("{}{}", prefix, "Group"), &field_value);
}
if let Some(ref field_value) = obj.user_id {
params.put(&format!("{}{}", prefix, "UserId"), &field_value);
}
}
}
struct LogDestinationTypeDeserializer;
impl LogDestinationTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LongDeserializer;
impl LongDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MarketTypeDeserializer;
impl MarketTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MillisecondDateTimeDeserializer;
impl MillisecondDateTimeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyCapacityReservationRequest {
pub capacity_reservation_id: String,
pub dry_run: Option<bool>,
pub end_date: Option<String>,
pub end_date_type: Option<String>,
pub instance_count: Option<i64>,
}
struct ModifyCapacityReservationRequestSerializer;
impl ModifyCapacityReservationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyCapacityReservationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CapacityReservationId"),
&obj.capacity_reservation_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.end_date {
params.put(&format!("{}{}", prefix, "EndDate"), &field_value);
}
if let Some(ref field_value) = obj.end_date_type {
params.put(&format!("{}{}", prefix, "EndDateType"), &field_value);
}
if let Some(ref field_value) = obj.instance_count {
params.put(&format!("{}{}", prefix, "InstanceCount"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyCapacityReservationResult {
pub return_: Option<bool>,
}
struct ModifyCapacityReservationResultDeserializer;
impl ModifyCapacityReservationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyCapacityReservationResult, XmlParseError> {
deserialize_elements::<_, ModifyCapacityReservationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyClientVpnEndpointRequest {
pub client_vpn_endpoint_id: String,
pub connection_log_options: Option<ConnectionLogOptions>,
pub description: Option<String>,
pub dns_servers: Option<DnsServersOptionsModifyStructure>,
pub dry_run: Option<bool>,
pub server_certificate_arn: Option<String>,
}
struct ModifyClientVpnEndpointRequestSerializer;
impl ModifyClientVpnEndpointRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClientVpnEndpointRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.connection_log_options {
ConnectionLogOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "ConnectionLogOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dns_servers {
DnsServersOptionsModifyStructureSerializer::serialize(
params,
&format!("{}{}", prefix, "DnsServers"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.server_certificate_arn {
params.put(
&format!("{}{}", prefix, "ServerCertificateArn"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyClientVpnEndpointResult {
pub return_: Option<bool>,
}
struct ModifyClientVpnEndpointResultDeserializer;
impl ModifyClientVpnEndpointResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClientVpnEndpointResult, XmlParseError> {
deserialize_elements::<_, ModifyClientVpnEndpointResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyEbsDefaultKmsKeyIdRequest {
pub dry_run: Option<bool>,
pub kms_key_id: String,
}
struct ModifyEbsDefaultKmsKeyIdRequestSerializer;
impl ModifyEbsDefaultKmsKeyIdRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyEbsDefaultKmsKeyIdRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "KmsKeyId"), &obj.kms_key_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyEbsDefaultKmsKeyIdResult {
pub kms_key_id: Option<String>,
}
struct ModifyEbsDefaultKmsKeyIdResultDeserializer;
impl ModifyEbsDefaultKmsKeyIdResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyEbsDefaultKmsKeyIdResult, XmlParseError> {
deserialize_elements::<_, ModifyEbsDefaultKmsKeyIdResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyFleetRequest {
pub dry_run: Option<bool>,
pub excess_capacity_termination_policy: Option<String>,
pub fleet_id: String,
pub target_capacity_specification: TargetCapacitySpecificationRequest,
}
struct ModifyFleetRequestSerializer;
impl ModifyFleetRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyFleetRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.excess_capacity_termination_policy {
params.put(
&format!("{}{}", prefix, "ExcessCapacityTerminationPolicy"),
&field_value,
);
}
params.put(&format!("{}{}", prefix, "FleetId"), &obj.fleet_id);
TargetCapacitySpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetCapacitySpecification"),
&obj.target_capacity_specification,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyFleetResult {
pub return_: Option<bool>,
}
struct ModifyFleetResultDeserializer;
impl ModifyFleetResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyFleetResult, XmlParseError> {
deserialize_elements::<_, ModifyFleetResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyFpgaImageAttributeRequest {
pub attribute: Option<String>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub fpga_image_id: String,
pub load_permission: Option<LoadPermissionModifications>,
pub name: Option<String>,
pub operation_type: Option<String>,
pub product_codes: Option<Vec<String>>,
pub user_groups: Option<Vec<String>>,
pub user_ids: Option<Vec<String>>,
}
struct ModifyFpgaImageAttributeRequestSerializer;
impl ModifyFpgaImageAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyFpgaImageAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute {
params.put(&format!("{}{}", prefix, "Attribute"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "FpgaImageId"), &obj.fpga_image_id);
if let Some(ref field_value) = obj.load_permission {
LoadPermissionModificationsSerializer::serialize(
params,
&format!("{}{}", prefix, "LoadPermission"),
field_value,
);
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
if let Some(ref field_value) = obj.operation_type {
params.put(&format!("{}{}", prefix, "OperationType"), &field_value);
}
if let Some(ref field_value) = obj.product_codes {
ProductCodeStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ProductCode"),
field_value,
);
}
if let Some(ref field_value) = obj.user_groups {
UserGroupStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "UserGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.user_ids {
UserIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "UserId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyFpgaImageAttributeResult {
pub fpga_image_attribute: Option<FpgaImageAttribute>,
}
struct ModifyFpgaImageAttributeResultDeserializer;
impl ModifyFpgaImageAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyFpgaImageAttributeResult, XmlParseError> {
deserialize_elements::<_, ModifyFpgaImageAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"fpgaImageAttribute" => {
obj.fpga_image_attribute =
Some(FpgaImageAttributeDeserializer::deserialize(
"fpgaImageAttribute",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyHostsRequest {
pub auto_placement: Option<String>,
pub host_ids: Vec<String>,
pub host_recovery: Option<String>,
}
struct ModifyHostsRequestSerializer;
impl ModifyHostsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyHostsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_placement {
params.put(&format!("{}{}", prefix, "AutoPlacement"), &field_value);
}
RequestHostIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "HostId"),
&obj.host_ids,
);
if let Some(ref field_value) = obj.host_recovery {
params.put(&format!("{}{}", prefix, "HostRecovery"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyHostsResult {
pub successful: Option<Vec<String>>,
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct ModifyHostsResultDeserializer;
impl ModifyHostsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyHostsResult, XmlParseError> {
deserialize_elements::<_, ModifyHostsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"successful" => {
obj.successful.get_or_insert(vec![]).extend(
ResponseHostIdListDeserializer::deserialize("successful", stack)?,
);
}
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemListDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyIdFormatRequest {
pub resource: String,
pub use_long_ids: bool,
}
struct ModifyIdFormatRequestSerializer;
impl ModifyIdFormatRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyIdFormatRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Resource"), &obj.resource);
params.put(&format!("{}{}", prefix, "UseLongIds"), &obj.use_long_ids);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyIdentityIdFormatRequest {
pub principal_arn: String,
pub resource: String,
pub use_long_ids: bool,
}
struct ModifyIdentityIdFormatRequestSerializer;
impl ModifyIdentityIdFormatRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyIdentityIdFormatRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "PrincipalArn"), &obj.principal_arn);
params.put(&format!("{}{}", prefix, "Resource"), &obj.resource);
params.put(&format!("{}{}", prefix, "UseLongIds"), &obj.use_long_ids);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyImageAttributeRequest {
pub attribute: Option<String>,
pub description: Option<AttributeValue>,
pub dry_run: Option<bool>,
pub image_id: String,
pub launch_permission: Option<LaunchPermissionModifications>,
pub operation_type: Option<String>,
pub product_codes: Option<Vec<String>>,
pub user_groups: Option<Vec<String>>,
pub user_ids: Option<Vec<String>>,
pub value: Option<String>,
}
struct ModifyImageAttributeRequestSerializer;
impl ModifyImageAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyImageAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute {
params.put(&format!("{}{}", prefix, "Attribute"), &field_value);
}
if let Some(ref field_value) = obj.description {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "Description"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "ImageId"), &obj.image_id);
if let Some(ref field_value) = obj.launch_permission {
LaunchPermissionModificationsSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchPermission"),
field_value,
);
}
if let Some(ref field_value) = obj.operation_type {
params.put(&format!("{}{}", prefix, "OperationType"), &field_value);
}
if let Some(ref field_value) = obj.product_codes {
ProductCodeStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ProductCode"),
field_value,
);
}
if let Some(ref field_value) = obj.user_groups {
UserGroupStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "UserGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.user_ids {
UserIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "UserId"),
field_value,
);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceAttributeRequest {
pub attribute: Option<String>,
pub block_device_mappings: Option<Vec<InstanceBlockDeviceMappingSpecification>>,
pub disable_api_termination: Option<AttributeBooleanValue>,
pub dry_run: Option<bool>,
pub ebs_optimized: Option<AttributeBooleanValue>,
pub ena_support: Option<AttributeBooleanValue>,
pub groups: Option<Vec<String>>,
pub instance_id: String,
pub instance_initiated_shutdown_behavior: Option<AttributeValue>,
pub instance_type: Option<AttributeValue>,
pub kernel: Option<AttributeValue>,
pub ramdisk: Option<AttributeValue>,
pub source_dest_check: Option<AttributeBooleanValue>,
pub sriov_net_support: Option<AttributeValue>,
pub user_data: Option<BlobAttributeValue>,
pub value: Option<String>,
}
struct ModifyInstanceAttributeRequestSerializer;
impl ModifyInstanceAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyInstanceAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute {
params.put(&format!("{}{}", prefix, "Attribute"), &field_value);
}
if let Some(ref field_value) = obj.block_device_mappings {
InstanceBlockDeviceMappingSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.disable_api_termination {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "DisableApiTermination"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.ebs_optimized {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "EbsOptimized"),
field_value,
);
}
if let Some(ref field_value) = obj.ena_support {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "EnaSupport"),
field_value,
);
}
if let Some(ref field_value) = obj.groups {
GroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupId"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
if let Some(ref field_value) = obj.instance_initiated_shutdown_behavior {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceInitiatedShutdownBehavior"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_type {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceType"),
field_value,
);
}
if let Some(ref field_value) = obj.kernel {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "Kernel"),
field_value,
);
}
if let Some(ref field_value) = obj.ramdisk {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "Ramdisk"),
field_value,
);
}
if let Some(ref field_value) = obj.source_dest_check {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "SourceDestCheck"),
field_value,
);
}
if let Some(ref field_value) = obj.sriov_net_support {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "SriovNetSupport"),
field_value,
);
}
if let Some(ref field_value) = obj.user_data {
BlobAttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "UserData"),
field_value,
);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceCapacityReservationAttributesRequest {
pub capacity_reservation_specification: CapacityReservationSpecification,
pub dry_run: Option<bool>,
pub instance_id: String,
}
struct ModifyInstanceCapacityReservationAttributesRequestSerializer;
impl ModifyInstanceCapacityReservationAttributesRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ModifyInstanceCapacityReservationAttributesRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
CapacityReservationSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "CapacityReservationSpecification"),
&obj.capacity_reservation_specification,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceCapacityReservationAttributesResult {
pub return_: Option<bool>,
}
struct ModifyInstanceCapacityReservationAttributesResultDeserializer;
impl ModifyInstanceCapacityReservationAttributesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyInstanceCapacityReservationAttributesResult, XmlParseError> {
deserialize_elements::<_, ModifyInstanceCapacityReservationAttributesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceCreditSpecificationRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub instance_credit_specifications: Vec<InstanceCreditSpecificationRequest>,
}
struct ModifyInstanceCreditSpecificationRequestSerializer;
impl ModifyInstanceCreditSpecificationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyInstanceCreditSpecificationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceCreditSpecificationListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceCreditSpecification"),
&obj.instance_credit_specifications,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceCreditSpecificationResult {
pub successful_instance_credit_specifications:
Option<Vec<SuccessfulInstanceCreditSpecificationItem>>,
pub unsuccessful_instance_credit_specifications:
Option<Vec<UnsuccessfulInstanceCreditSpecificationItem>>,
}
struct ModifyInstanceCreditSpecificationResultDeserializer;
impl ModifyInstanceCreditSpecificationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyInstanceCreditSpecificationResult, XmlParseError> {
deserialize_elements::<_, ModifyInstanceCreditSpecificationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"successfulInstanceCreditSpecificationSet" => {
obj.successful_instance_credit_specifications
.get_or_insert(vec![])
.extend(
SuccessfulInstanceCreditSpecificationSetDeserializer::deserialize(
"successfulInstanceCreditSpecificationSet",
stack,
)?,
);
}
"unsuccessfulInstanceCreditSpecificationSet" => {
obj.unsuccessful_instance_credit_specifications
.get_or_insert(vec![])
.extend(UnsuccessfulInstanceCreditSpecificationSetDeserializer::deserialize("unsuccessfulInstanceCreditSpecificationSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceEventStartTimeRequest {
pub dry_run: Option<bool>,
pub instance_event_id: String,
pub instance_id: String,
pub not_before: String,
}
struct ModifyInstanceEventStartTimeRequestSerializer;
impl ModifyInstanceEventStartTimeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyInstanceEventStartTimeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InstanceEventId"),
&obj.instance_event_id,
);
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(&format!("{}{}", prefix, "NotBefore"), &obj.not_before);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstanceEventStartTimeResult {
pub event: Option<InstanceStatusEvent>,
}
struct ModifyInstanceEventStartTimeResultDeserializer;
impl ModifyInstanceEventStartTimeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyInstanceEventStartTimeResult, XmlParseError> {
deserialize_elements::<_, ModifyInstanceEventStartTimeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"event" => {
obj.event = Some(InstanceStatusEventDeserializer::deserialize(
"event", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstancePlacementRequest {
pub affinity: Option<String>,
pub group_name: Option<String>,
pub host_id: Option<String>,
pub instance_id: String,
pub partition_number: Option<i64>,
pub tenancy: Option<String>,
}
struct ModifyInstancePlacementRequestSerializer;
impl ModifyInstancePlacementRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyInstancePlacementRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.affinity {
params.put(&format!("{}{}", prefix, "Affinity"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.host_id {
params.put(&format!("{}{}", prefix, "HostId"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
if let Some(ref field_value) = obj.partition_number {
params.put(&format!("{}{}", prefix, "PartitionNumber"), &field_value);
}
if let Some(ref field_value) = obj.tenancy {
params.put(&format!("{}{}", prefix, "Tenancy"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyInstancePlacementResult {
pub return_: Option<bool>,
}
struct ModifyInstancePlacementResultDeserializer;
impl ModifyInstancePlacementResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyInstancePlacementResult, XmlParseError> {
deserialize_elements::<_, ModifyInstancePlacementResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyLaunchTemplateRequest {
pub client_token: Option<String>,
pub default_version: Option<String>,
pub dry_run: Option<bool>,
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
}
struct ModifyLaunchTemplateRequestSerializer;
impl ModifyLaunchTemplateRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyLaunchTemplateRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.default_version {
params.put(&format!("{}{}", prefix, "SetDefaultVersion"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyLaunchTemplateResult {
pub launch_template: Option<LaunchTemplate>,
}
struct ModifyLaunchTemplateResultDeserializer;
impl ModifyLaunchTemplateResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyLaunchTemplateResult, XmlParseError> {
deserialize_elements::<_, ModifyLaunchTemplateResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"launchTemplate" => {
obj.launch_template = Some(LaunchTemplateDeserializer::deserialize(
"launchTemplate",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyNetworkInterfaceAttributeRequest {
pub attachment: Option<NetworkInterfaceAttachmentChanges>,
pub description: Option<AttributeValue>,
pub dry_run: Option<bool>,
pub groups: Option<Vec<String>>,
pub network_interface_id: String,
pub source_dest_check: Option<AttributeBooleanValue>,
}
struct ModifyNetworkInterfaceAttributeRequestSerializer;
impl ModifyNetworkInterfaceAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyNetworkInterfaceAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attachment {
NetworkInterfaceAttachmentChangesSerializer::serialize(
params,
&format!("{}{}", prefix, "Attachment"),
field_value,
);
}
if let Some(ref field_value) = obj.description {
AttributeValueSerializer::serialize(
params,
&format!("{}{}", prefix, "Description"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.groups {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
if let Some(ref field_value) = obj.source_dest_check {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "SourceDestCheck"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyReservedInstancesRequest {
pub client_token: Option<String>,
pub reserved_instances_ids: Vec<String>,
pub target_configurations: Vec<ReservedInstancesConfiguration>,
}
struct ModifyReservedInstancesRequestSerializer;
impl ModifyReservedInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyReservedInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
ReservedInstancesIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstancesId"),
&obj.reserved_instances_ids,
);
ReservedInstancesConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReservedInstancesConfigurationSetItemType"),
&obj.target_configurations,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyReservedInstancesResult {
pub reserved_instances_modification_id: Option<String>,
}
struct ModifyReservedInstancesResultDeserializer;
impl ModifyReservedInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyReservedInstancesResult, XmlParseError> {
deserialize_elements::<_, ModifyReservedInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesModificationId" => {
obj.reserved_instances_modification_id =
Some(StringDeserializer::deserialize(
"reservedInstancesModificationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifySnapshotAttributeRequest {
pub attribute: Option<String>,
pub create_volume_permission: Option<CreateVolumePermissionModifications>,
pub dry_run: Option<bool>,
pub group_names: Option<Vec<String>>,
pub operation_type: Option<String>,
pub snapshot_id: String,
pub user_ids: Option<Vec<String>>,
}
struct ModifySnapshotAttributeRequestSerializer;
impl ModifySnapshotAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifySnapshotAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute {
params.put(&format!("{}{}", prefix, "Attribute"), &field_value);
}
if let Some(ref field_value) = obj.create_volume_permission {
CreateVolumePermissionModificationsSerializer::serialize(
params,
&format!("{}{}", prefix, "CreateVolumePermission"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.group_names {
GroupNameStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "UserGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.operation_type {
params.put(&format!("{}{}", prefix, "OperationType"), &field_value);
}
params.put(&format!("{}{}", prefix, "SnapshotId"), &obj.snapshot_id);
if let Some(ref field_value) = obj.user_ids {
UserIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "UserId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifySpotFleetRequestRequest {
pub excess_capacity_termination_policy: Option<String>,
pub spot_fleet_request_id: String,
pub target_capacity: Option<i64>,
}
struct ModifySpotFleetRequestRequestSerializer;
impl ModifySpotFleetRequestRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifySpotFleetRequestRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.excess_capacity_termination_policy {
params.put(
&format!("{}{}", prefix, "ExcessCapacityTerminationPolicy"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SpotFleetRequestId"),
&obj.spot_fleet_request_id,
);
if let Some(ref field_value) = obj.target_capacity {
params.put(&format!("{}{}", prefix, "TargetCapacity"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifySpotFleetRequestResponse {
pub return_: Option<bool>,
}
struct ModifySpotFleetRequestResponseDeserializer;
impl ModifySpotFleetRequestResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifySpotFleetRequestResponse, XmlParseError> {
deserialize_elements::<_, ModifySpotFleetRequestResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifySubnetAttributeRequest {
pub assign_ipv_6_address_on_creation: Option<AttributeBooleanValue>,
pub map_public_ip_on_launch: Option<AttributeBooleanValue>,
pub subnet_id: String,
}
struct ModifySubnetAttributeRequestSerializer;
impl ModifySubnetAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifySubnetAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.assign_ipv_6_address_on_creation {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "AssignIpv6AddressOnCreation"),
field_value,
);
}
if let Some(ref field_value) = obj.map_public_ip_on_launch {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "MapPublicIpOnLaunch"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "SubnetId"), &obj.subnet_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyTransitGatewayVpcAttachmentRequest {
pub add_subnet_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub options: Option<ModifyTransitGatewayVpcAttachmentRequestOptions>,
pub remove_subnet_ids: Option<Vec<String>>,
pub transit_gateway_attachment_id: String,
}
struct ModifyTransitGatewayVpcAttachmentRequestSerializer;
impl ModifyTransitGatewayVpcAttachmentRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyTransitGatewayVpcAttachmentRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add_subnet_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AddSubnetIds"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.options {
ModifyTransitGatewayVpcAttachmentRequestOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Options"),
field_value,
);
}
if let Some(ref field_value) = obj.remove_subnet_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RemoveSubnetIds"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyTransitGatewayVpcAttachmentRequestOptions {
pub dns_support: Option<String>,
pub ipv_6_support: Option<String>,
}
struct ModifyTransitGatewayVpcAttachmentRequestOptionsSerializer;
impl ModifyTransitGatewayVpcAttachmentRequestOptionsSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ModifyTransitGatewayVpcAttachmentRequestOptions,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dns_support {
params.put(&format!("{}{}", prefix, "DnsSupport"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_support {
params.put(&format!("{}{}", prefix, "Ipv6Support"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyTransitGatewayVpcAttachmentResult {
pub transit_gateway_vpc_attachment: Option<TransitGatewayVpcAttachment>,
}
struct ModifyTransitGatewayVpcAttachmentResultDeserializer;
impl ModifyTransitGatewayVpcAttachmentResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyTransitGatewayVpcAttachmentResult, XmlParseError> {
deserialize_elements::<_, ModifyTransitGatewayVpcAttachmentResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayVpcAttachment" => {
obj.transit_gateway_vpc_attachment =
Some(TransitGatewayVpcAttachmentDeserializer::deserialize(
"transitGatewayVpcAttachment",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVolumeAttributeRequest {
pub auto_enable_io: Option<AttributeBooleanValue>,
pub dry_run: Option<bool>,
pub volume_id: String,
}
struct ModifyVolumeAttributeRequestSerializer;
impl ModifyVolumeAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVolumeAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_enable_io {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "AutoEnableIO"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVolumeRequest {
pub dry_run: Option<bool>,
pub iops: Option<i64>,
pub size: Option<i64>,
pub volume_id: String,
pub volume_type: Option<String>,
}
struct ModifyVolumeRequestSerializer;
impl ModifyVolumeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVolumeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value);
}
if let Some(ref field_value) = obj.size {
params.put(&format!("{}{}", prefix, "Size"), &field_value);
}
params.put(&format!("{}{}", prefix, "VolumeId"), &obj.volume_id);
if let Some(ref field_value) = obj.volume_type {
params.put(&format!("{}{}", prefix, "VolumeType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVolumeResult {
pub volume_modification: Option<VolumeModification>,
}
struct ModifyVolumeResultDeserializer;
impl ModifyVolumeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVolumeResult, XmlParseError> {
deserialize_elements::<_, ModifyVolumeResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"volumeModification" => {
obj.volume_modification = Some(VolumeModificationDeserializer::deserialize(
"volumeModification",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcAttributeRequest {
pub enable_dns_hostnames: Option<AttributeBooleanValue>,
pub enable_dns_support: Option<AttributeBooleanValue>,
pub vpc_id: String,
}
struct ModifyVpcAttributeRequestSerializer;
impl ModifyVpcAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVpcAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enable_dns_hostnames {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "EnableDnsHostnames"),
field_value,
);
}
if let Some(ref field_value) = obj.enable_dns_support {
AttributeBooleanValueSerializer::serialize(
params,
&format!("{}{}", prefix, "EnableDnsSupport"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointConnectionNotificationRequest {
pub connection_events: Option<Vec<String>>,
pub connection_notification_arn: Option<String>,
pub connection_notification_id: String,
pub dry_run: Option<bool>,
}
struct ModifyVpcEndpointConnectionNotificationRequestSerializer;
impl ModifyVpcEndpointConnectionNotificationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ModifyVpcEndpointConnectionNotificationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.connection_events {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "ConnectionEvents"),
field_value,
);
}
if let Some(ref field_value) = obj.connection_notification_arn {
params.put(
&format!("{}{}", prefix, "ConnectionNotificationArn"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ConnectionNotificationId"),
&obj.connection_notification_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointConnectionNotificationResult {
pub return_value: Option<bool>,
}
struct ModifyVpcEndpointConnectionNotificationResultDeserializer;
impl ModifyVpcEndpointConnectionNotificationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpcEndpointConnectionNotificationResult, XmlParseError> {
deserialize_elements::<_, ModifyVpcEndpointConnectionNotificationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_value = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointRequest {
pub add_route_table_ids: Option<Vec<String>>,
pub add_security_group_ids: Option<Vec<String>>,
pub add_subnet_ids: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub policy_document: Option<String>,
pub private_dns_enabled: Option<bool>,
pub remove_route_table_ids: Option<Vec<String>>,
pub remove_security_group_ids: Option<Vec<String>>,
pub remove_subnet_ids: Option<Vec<String>>,
pub reset_policy: Option<bool>,
pub vpc_endpoint_id: String,
}
struct ModifyVpcEndpointRequestSerializer;
impl ModifyVpcEndpointRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVpcEndpointRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add_route_table_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AddRouteTableId"),
field_value,
);
}
if let Some(ref field_value) = obj.add_security_group_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AddSecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.add_subnet_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AddSubnetId"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.policy_document {
params.put(&format!("{}{}", prefix, "PolicyDocument"), &field_value);
}
if let Some(ref field_value) = obj.private_dns_enabled {
params.put(&format!("{}{}", prefix, "PrivateDnsEnabled"), &field_value);
}
if let Some(ref field_value) = obj.remove_route_table_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RemoveRouteTableId"),
field_value,
);
}
if let Some(ref field_value) = obj.remove_security_group_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RemoveSecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.remove_subnet_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RemoveSubnetId"),
field_value,
);
}
if let Some(ref field_value) = obj.reset_policy {
params.put(&format!("{}{}", prefix, "ResetPolicy"), &field_value);
}
params.put(
&format!("{}{}", prefix, "VpcEndpointId"),
&obj.vpc_endpoint_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointResult {
pub return_: Option<bool>,
}
struct ModifyVpcEndpointResultDeserializer;
impl ModifyVpcEndpointResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpcEndpointResult, XmlParseError> {
deserialize_elements::<_, ModifyVpcEndpointResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointServiceConfigurationRequest {
pub acceptance_required: Option<bool>,
pub add_network_load_balancer_arns: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub remove_network_load_balancer_arns: Option<Vec<String>>,
pub service_id: String,
}
struct ModifyVpcEndpointServiceConfigurationRequestSerializer;
impl ModifyVpcEndpointServiceConfigurationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ModifyVpcEndpointServiceConfigurationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.acceptance_required {
params.put(&format!("{}{}", prefix, "AcceptanceRequired"), &field_value);
}
if let Some(ref field_value) = obj.add_network_load_balancer_arns {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AddNetworkLoadBalancerArn"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.remove_network_load_balancer_arns {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RemoveNetworkLoadBalancerArn"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "ServiceId"), &obj.service_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointServiceConfigurationResult {
pub return_: Option<bool>,
}
struct ModifyVpcEndpointServiceConfigurationResultDeserializer;
impl ModifyVpcEndpointServiceConfigurationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpcEndpointServiceConfigurationResult, XmlParseError> {
deserialize_elements::<_, ModifyVpcEndpointServiceConfigurationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointServicePermissionsRequest {
pub add_allowed_principals: Option<Vec<String>>,
pub dry_run: Option<bool>,
pub remove_allowed_principals: Option<Vec<String>>,
pub service_id: String,
}
struct ModifyVpcEndpointServicePermissionsRequestSerializer;
impl ModifyVpcEndpointServicePermissionsRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ModifyVpcEndpointServicePermissionsRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add_allowed_principals {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "AddAllowedPrincipals"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.remove_allowed_principals {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "RemoveAllowedPrincipals"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "ServiceId"), &obj.service_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcEndpointServicePermissionsResult {
pub return_value: Option<bool>,
}
struct ModifyVpcEndpointServicePermissionsResultDeserializer;
impl ModifyVpcEndpointServicePermissionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpcEndpointServicePermissionsResult, XmlParseError> {
deserialize_elements::<_, ModifyVpcEndpointServicePermissionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_value = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcPeeringConnectionOptionsRequest {
pub accepter_peering_connection_options: Option<PeeringConnectionOptionsRequest>,
pub dry_run: Option<bool>,
pub requester_peering_connection_options: Option<PeeringConnectionOptionsRequest>,
pub vpc_peering_connection_id: String,
}
struct ModifyVpcPeeringConnectionOptionsRequestSerializer;
impl ModifyVpcPeeringConnectionOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVpcPeeringConnectionOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.accepter_peering_connection_options {
PeeringConnectionOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "AccepterPeeringConnectionOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.requester_peering_connection_options {
PeeringConnectionOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "RequesterPeeringConnectionOptions"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&obj.vpc_peering_connection_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcPeeringConnectionOptionsResult {
pub accepter_peering_connection_options: Option<PeeringConnectionOptions>,
pub requester_peering_connection_options: Option<PeeringConnectionOptions>,
}
struct ModifyVpcPeeringConnectionOptionsResultDeserializer;
impl ModifyVpcPeeringConnectionOptionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpcPeeringConnectionOptionsResult, XmlParseError> {
deserialize_elements::<_, ModifyVpcPeeringConnectionOptionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"accepterPeeringConnectionOptions" => {
obj.accepter_peering_connection_options =
Some(PeeringConnectionOptionsDeserializer::deserialize(
"accepterPeeringConnectionOptions",
stack,
)?);
}
"requesterPeeringConnectionOptions" => {
obj.requester_peering_connection_options =
Some(PeeringConnectionOptionsDeserializer::deserialize(
"requesterPeeringConnectionOptions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcTenancyRequest {
pub dry_run: Option<bool>,
pub instance_tenancy: String,
pub vpc_id: String,
}
struct ModifyVpcTenancyRequestSerializer;
impl ModifyVpcTenancyRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVpcTenancyRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InstanceTenancy"),
&obj.instance_tenancy,
);
params.put(&format!("{}{}", prefix, "VpcId"), &obj.vpc_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpcTenancyResult {
pub return_value: Option<bool>,
}
struct ModifyVpcTenancyResultDeserializer;
impl ModifyVpcTenancyResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpcTenancyResult, XmlParseError> {
deserialize_elements::<_, ModifyVpcTenancyResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"return" => {
obj.return_value = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpnConnectionRequest {
pub dry_run: Option<bool>,
pub transit_gateway_id: Option<String>,
pub vpn_connection_id: String,
pub vpn_gateway_id: Option<String>,
}
struct ModifyVpnConnectionRequestSerializer;
impl ModifyVpnConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyVpnConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_id {
params.put(&format!("{}{}", prefix, "TransitGatewayId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "VpnConnectionId"),
&obj.vpn_connection_id,
);
if let Some(ref field_value) = obj.vpn_gateway_id {
params.put(&format!("{}{}", prefix, "VpnGatewayId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyVpnConnectionResult {
pub vpn_connection: Option<VpnConnection>,
}
struct ModifyVpnConnectionResultDeserializer;
impl ModifyVpnConnectionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyVpnConnectionResult, XmlParseError> {
deserialize_elements::<_, ModifyVpnConnectionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"vpnConnection" => {
obj.vpn_connection = Some(VpnConnectionDeserializer::deserialize(
"vpnConnection",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MonitorInstancesRequest {
pub dry_run: Option<bool>,
pub instance_ids: Vec<String>,
}
struct MonitorInstancesRequestSerializer;
impl MonitorInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &MonitorInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instance_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MonitorInstancesResult {
pub instance_monitorings: Option<Vec<InstanceMonitoring>>,
}
struct MonitorInstancesResultDeserializer;
impl MonitorInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MonitorInstancesResult, XmlParseError> {
deserialize_elements::<_, MonitorInstancesResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"instancesSet" => {
obj.instance_monitorings.get_or_insert(vec![]).extend(
InstanceMonitoringListDeserializer::deserialize("instancesSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Monitoring {
pub state: Option<String>,
}
struct MonitoringDeserializer;
impl MonitoringDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Monitoring, XmlParseError> {
deserialize_elements::<_, Monitoring, _>(tag_name, stack, |name, stack, obj| {
match name {
"state" => {
obj.state = Some(MonitoringStateDeserializer::deserialize("state", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct MonitoringStateDeserializer;
impl MonitoringStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MoveAddressToVpcRequest {
pub dry_run: Option<bool>,
pub public_ip: String,
}
struct MoveAddressToVpcRequestSerializer;
impl MoveAddressToVpcRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &MoveAddressToVpcRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "PublicIp"), &obj.public_ip);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MoveAddressToVpcResult {
pub allocation_id: Option<String>,
pub status: Option<String>,
}
struct MoveAddressToVpcResultDeserializer;
impl MoveAddressToVpcResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MoveAddressToVpcResult, XmlParseError> {
deserialize_elements::<_, MoveAddressToVpcResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationId" => {
obj.allocation_id =
Some(StringDeserializer::deserialize("allocationId", stack)?);
}
"status" => {
obj.status = Some(StatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct MoveStatusDeserializer;
impl MoveStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MovingAddressStatus {
pub move_status: Option<String>,
pub public_ip: Option<String>,
}
struct MovingAddressStatusDeserializer;
impl MovingAddressStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MovingAddressStatus, XmlParseError> {
deserialize_elements::<_, MovingAddressStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"moveStatus" => {
obj.move_status =
Some(MoveStatusDeserializer::deserialize("moveStatus", stack)?);
}
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct MovingAddressStatusSetDeserializer;
impl MovingAddressStatusSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MovingAddressStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(MovingAddressStatusDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NatGateway {
pub create_time: Option<String>,
pub delete_time: Option<String>,
pub failure_code: Option<String>,
pub failure_message: Option<String>,
pub nat_gateway_addresses: Option<Vec<NatGatewayAddress>>,
pub nat_gateway_id: Option<String>,
pub provisioned_bandwidth: Option<ProvisionedBandwidth>,
pub state: Option<String>,
pub subnet_id: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct NatGatewayDeserializer;
impl NatGatewayDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NatGateway, XmlParseError> {
deserialize_elements::<_, NatGateway, _>(tag_name, stack, |name, stack, obj| {
match name {
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"deleteTime" => {
obj.delete_time = Some(DateTimeDeserializer::deserialize("deleteTime", stack)?);
}
"failureCode" => {
obj.failure_code = Some(StringDeserializer::deserialize("failureCode", stack)?);
}
"failureMessage" => {
obj.failure_message =
Some(StringDeserializer::deserialize("failureMessage", stack)?);
}
"natGatewayAddressSet" => {
obj.nat_gateway_addresses.get_or_insert(vec![]).extend(
NatGatewayAddressListDeserializer::deserialize(
"natGatewayAddressSet",
stack,
)?,
);
}
"natGatewayId" => {
obj.nat_gateway_id =
Some(StringDeserializer::deserialize("natGatewayId", stack)?);
}
"provisionedBandwidth" => {
obj.provisioned_bandwidth =
Some(ProvisionedBandwidthDeserializer::deserialize(
"provisionedBandwidth",
stack,
)?);
}
"state" => {
obj.state = Some(NatGatewayStateDeserializer::deserialize("state", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NatGatewayAddress {
pub allocation_id: Option<String>,
pub network_interface_id: Option<String>,
pub private_ip: Option<String>,
pub public_ip: Option<String>,
}
struct NatGatewayAddressDeserializer;
impl NatGatewayAddressDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NatGatewayAddress, XmlParseError> {
deserialize_elements::<_, NatGatewayAddress, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationId" => {
obj.allocation_id =
Some(StringDeserializer::deserialize("allocationId", stack)?);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"privateIp" => {
obj.private_ip = Some(StringDeserializer::deserialize("privateIp", stack)?);
}
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct NatGatewayAddressListDeserializer;
impl NatGatewayAddressListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NatGatewayAddress>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NatGatewayAddressDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NatGatewayListDeserializer;
impl NatGatewayListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NatGateway>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NatGatewayDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NatGatewayStateDeserializer;
impl NatGatewayStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkAcl {
pub associations: Option<Vec<NetworkAclAssociation>>,
pub entries: Option<Vec<NetworkAclEntry>>,
pub is_default: Option<bool>,
pub network_acl_id: Option<String>,
pub owner_id: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct NetworkAclDeserializer;
impl NetworkAclDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkAcl, XmlParseError> {
deserialize_elements::<_, NetworkAcl, _>(tag_name, stack, |name, stack, obj| {
match name {
"associationSet" => {
obj.associations.get_or_insert(vec![]).extend(
NetworkAclAssociationListDeserializer::deserialize(
"associationSet",
stack,
)?,
);
}
"entrySet" => {
obj.entries.get_or_insert(vec![]).extend(
NetworkAclEntryListDeserializer::deserialize("entrySet", stack)?,
);
}
"default" => {
obj.is_default = Some(BooleanDeserializer::deserialize("default", stack)?);
}
"networkAclId" => {
obj.network_acl_id =
Some(StringDeserializer::deserialize("networkAclId", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkAclAssociation {
pub network_acl_association_id: Option<String>,
pub network_acl_id: Option<String>,
pub subnet_id: Option<String>,
}
struct NetworkAclAssociationDeserializer;
impl NetworkAclAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkAclAssociation, XmlParseError> {
deserialize_elements::<_, NetworkAclAssociation, _>(tag_name, stack, |name, stack, obj| {
match name {
"networkAclAssociationId" => {
obj.network_acl_association_id = Some(StringDeserializer::deserialize(
"networkAclAssociationId",
stack,
)?);
}
"networkAclId" => {
obj.network_acl_id =
Some(StringDeserializer::deserialize("networkAclId", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct NetworkAclAssociationListDeserializer;
impl NetworkAclAssociationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkAclAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkAclAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkAclEntry {
pub cidr_block: Option<String>,
pub egress: Option<bool>,
pub icmp_type_code: Option<IcmpTypeCode>,
pub ipv_6_cidr_block: Option<String>,
pub port_range: Option<PortRange>,
pub protocol: Option<String>,
pub rule_action: Option<String>,
pub rule_number: Option<i64>,
}
struct NetworkAclEntryDeserializer;
impl NetworkAclEntryDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkAclEntry, XmlParseError> {
deserialize_elements::<_, NetworkAclEntry, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidrBlock" => {
obj.cidr_block = Some(StringDeserializer::deserialize("cidrBlock", stack)?);
}
"egress" => {
obj.egress = Some(BooleanDeserializer::deserialize("egress", stack)?);
}
"icmpTypeCode" => {
obj.icmp_type_code = Some(IcmpTypeCodeDeserializer::deserialize(
"icmpTypeCode",
stack,
)?);
}
"ipv6CidrBlock" => {
obj.ipv_6_cidr_block =
Some(StringDeserializer::deserialize("ipv6CidrBlock", stack)?);
}
"portRange" => {
obj.port_range = Some(PortRangeDeserializer::deserialize("portRange", stack)?);
}
"protocol" => {
obj.protocol = Some(StringDeserializer::deserialize("protocol", stack)?);
}
"ruleAction" => {
obj.rule_action =
Some(RuleActionDeserializer::deserialize("ruleAction", stack)?);
}
"ruleNumber" => {
obj.rule_number = Some(IntegerDeserializer::deserialize("ruleNumber", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct NetworkAclEntryListDeserializer;
impl NetworkAclEntryListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkAclEntry>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkAclEntryDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NetworkAclListDeserializer;
impl NetworkAclListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkAcl>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkAclDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterface {
pub association: Option<NetworkInterfaceAssociation>,
pub attachment: Option<NetworkInterfaceAttachment>,
pub availability_zone: Option<String>,
pub description: Option<String>,
pub groups: Option<Vec<GroupIdentifier>>,
pub interface_type: Option<String>,
pub ipv_6_addresses: Option<Vec<NetworkInterfaceIpv6Address>>,
pub mac_address: Option<String>,
pub network_interface_id: Option<String>,
pub owner_id: Option<String>,
pub private_dns_name: Option<String>,
pub private_ip_address: Option<String>,
pub private_ip_addresses: Option<Vec<NetworkInterfacePrivateIpAddress>>,
pub requester_id: Option<String>,
pub requester_managed: Option<bool>,
pub source_dest_check: Option<bool>,
pub status: Option<String>,
pub subnet_id: Option<String>,
pub tag_set: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct NetworkInterfaceDeserializer;
impl NetworkInterfaceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterface, XmlParseError> {
deserialize_elements::<_, NetworkInterface, _>(tag_name, stack, |name, stack, obj| {
match name {
"association" => {
obj.association = Some(NetworkInterfaceAssociationDeserializer::deserialize(
"association",
stack,
)?);
}
"attachment" => {
obj.attachment = Some(NetworkInterfaceAttachmentDeserializer::deserialize(
"attachment",
stack,
)?);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"interfaceType" => {
obj.interface_type = Some(NetworkInterfaceTypeDeserializer::deserialize(
"interfaceType",
stack,
)?);
}
"ipv6AddressesSet" => {
obj.ipv_6_addresses.get_or_insert(vec![]).extend(
NetworkInterfaceIpv6AddressesListDeserializer::deserialize(
"ipv6AddressesSet",
stack,
)?,
);
}
"macAddress" => {
obj.mac_address = Some(StringDeserializer::deserialize("macAddress", stack)?);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
"privateIpAddressesSet" => {
obj.private_ip_addresses.get_or_insert(vec![]).extend(
NetworkInterfacePrivateIpAddressListDeserializer::deserialize(
"privateIpAddressesSet",
stack,
)?,
);
}
"requesterId" => {
obj.requester_id = Some(StringDeserializer::deserialize("requesterId", stack)?);
}
"requesterManaged" => {
obj.requester_managed =
Some(BooleanDeserializer::deserialize("requesterManaged", stack)?);
}
"sourceDestCheck" => {
obj.source_dest_check =
Some(BooleanDeserializer::deserialize("sourceDestCheck", stack)?);
}
"status" => {
obj.status = Some(NetworkInterfaceStatusDeserializer::deserialize(
"status", stack,
)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"tagSet" => {
obj.tag_set
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfaceAssociation {
pub allocation_id: Option<String>,
pub association_id: Option<String>,
pub ip_owner_id: Option<String>,
pub public_dns_name: Option<String>,
pub public_ip: Option<String>,
}
struct NetworkInterfaceAssociationDeserializer;
impl NetworkInterfaceAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterfaceAssociation, XmlParseError> {
deserialize_elements::<_, NetworkInterfaceAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"allocationId" => {
obj.allocation_id =
Some(StringDeserializer::deserialize("allocationId", stack)?);
}
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"ipOwnerId" => {
obj.ip_owner_id =
Some(StringDeserializer::deserialize("ipOwnerId", stack)?);
}
"publicDnsName" => {
obj.public_dns_name =
Some(StringDeserializer::deserialize("publicDnsName", stack)?);
}
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfaceAttachment {
pub attach_time: Option<String>,
pub attachment_id: Option<String>,
pub delete_on_termination: Option<bool>,
pub device_index: Option<i64>,
pub instance_id: Option<String>,
pub instance_owner_id: Option<String>,
pub status: Option<String>,
}
struct NetworkInterfaceAttachmentDeserializer;
impl NetworkInterfaceAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterfaceAttachment, XmlParseError> {
deserialize_elements::<_, NetworkInterfaceAttachment, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"attachTime" => {
obj.attach_time =
Some(DateTimeDeserializer::deserialize("attachTime", stack)?);
}
"attachmentId" => {
obj.attachment_id =
Some(StringDeserializer::deserialize("attachmentId", stack)?);
}
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"deviceIndex" => {
obj.device_index =
Some(IntegerDeserializer::deserialize("deviceIndex", stack)?);
}
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceOwnerId" => {
obj.instance_owner_id =
Some(StringDeserializer::deserialize("instanceOwnerId", stack)?);
}
"status" => {
obj.status =
Some(AttachmentStatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfaceAttachmentChanges {
pub attachment_id: Option<String>,
pub delete_on_termination: Option<bool>,
}
struct NetworkInterfaceAttachmentChangesSerializer;
impl NetworkInterfaceAttachmentChangesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &NetworkInterfaceAttachmentChanges) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attachment_id {
params.put(&format!("{}{}", prefix, "AttachmentId"), &field_value);
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
}
}
struct NetworkInterfaceIdListSerializer;
impl NetworkInterfaceIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfaceIpv6Address {
pub ipv_6_address: Option<String>,
}
struct NetworkInterfaceIpv6AddressDeserializer;
impl NetworkInterfaceIpv6AddressDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterfaceIpv6Address, XmlParseError> {
deserialize_elements::<_, NetworkInterfaceIpv6Address, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ipv6Address" => {
obj.ipv_6_address =
Some(StringDeserializer::deserialize("ipv6Address", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct NetworkInterfaceIpv6AddressesListDeserializer;
impl NetworkInterfaceIpv6AddressesListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkInterfaceIpv6Address>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkInterfaceIpv6AddressDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NetworkInterfaceListDeserializer;
impl NetworkInterfaceListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkInterface>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkInterfaceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfacePermission {
pub aws_account_id: Option<String>,
pub aws_service: Option<String>,
pub network_interface_id: Option<String>,
pub network_interface_permission_id: Option<String>,
pub permission: Option<String>,
pub permission_state: Option<NetworkInterfacePermissionState>,
}
struct NetworkInterfacePermissionDeserializer;
impl NetworkInterfacePermissionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterfacePermission, XmlParseError> {
deserialize_elements::<_, NetworkInterfacePermission, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"awsAccountId" => {
obj.aws_account_id =
Some(StringDeserializer::deserialize("awsAccountId", stack)?);
}
"awsService" => {
obj.aws_service =
Some(StringDeserializer::deserialize("awsService", stack)?);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"networkInterfacePermissionId" => {
obj.network_interface_permission_id = Some(
StringDeserializer::deserialize("networkInterfacePermissionId", stack)?,
);
}
"permission" => {
obj.permission = Some(InterfacePermissionTypeDeserializer::deserialize(
"permission",
stack,
)?);
}
"permissionState" => {
obj.permission_state =
Some(NetworkInterfacePermissionStateDeserializer::deserialize(
"permissionState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct NetworkInterfacePermissionIdListSerializer;
impl NetworkInterfacePermissionIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct NetworkInterfacePermissionListDeserializer;
impl NetworkInterfacePermissionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkInterfacePermission>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkInterfacePermissionDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfacePermissionState {
pub state: Option<String>,
pub status_message: Option<String>,
}
struct NetworkInterfacePermissionStateDeserializer;
impl NetworkInterfacePermissionStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterfacePermissionState, XmlParseError> {
deserialize_elements::<_, NetworkInterfacePermissionState, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"state" => {
obj.state = Some(
NetworkInterfacePermissionStateCodeDeserializer::deserialize(
"state", stack,
)?,
);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct NetworkInterfacePermissionStateCodeDeserializer;
impl NetworkInterfacePermissionStateCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NetworkInterfacePrivateIpAddress {
pub association: Option<NetworkInterfaceAssociation>,
pub primary: Option<bool>,
pub private_dns_name: Option<String>,
pub private_ip_address: Option<String>,
}
struct NetworkInterfacePrivateIpAddressDeserializer;
impl NetworkInterfacePrivateIpAddressDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NetworkInterfacePrivateIpAddress, XmlParseError> {
deserialize_elements::<_, NetworkInterfacePrivateIpAddress, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"association" => {
obj.association =
Some(NetworkInterfaceAssociationDeserializer::deserialize(
"association",
stack,
)?);
}
"primary" => {
obj.primary = Some(BooleanDeserializer::deserialize("primary", stack)?);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct NetworkInterfacePrivateIpAddressListDeserializer;
impl NetworkInterfacePrivateIpAddressListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NetworkInterfacePrivateIpAddress>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(NetworkInterfacePrivateIpAddressDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NetworkInterfaceStatusDeserializer;
impl NetworkInterfaceStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct NetworkInterfaceTypeDeserializer;
impl NetworkInterfaceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NewDhcpConfiguration {
pub key: Option<String>,
pub values: Option<Vec<String>>,
}
struct NewDhcpConfigurationSerializer;
impl NewDhcpConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &NewDhcpConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.key {
params.put(&format!("{}{}", prefix, "Key"), &field_value);
}
if let Some(ref field_value) = obj.values {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "Value"),
field_value,
);
}
}
}
struct NewDhcpConfigurationListSerializer;
impl NewDhcpConfigurationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<NewDhcpConfiguration>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
NewDhcpConfigurationSerializer::serialize(params, &key, obj);
}
}
}
struct NextTokenDeserializer;
impl NextTokenDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct OccurrenceDayRequestSetSerializer;
impl OccurrenceDayRequestSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<i64>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct OccurrenceDaySetDeserializer;
impl OccurrenceDaySetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<i64>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(IntegerDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct OfferingClassTypeDeserializer;
impl OfferingClassTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct OfferingTypeValuesDeserializer;
impl OfferingTypeValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct OnDemandAllocationStrategyDeserializer;
impl OnDemandAllocationStrategyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OnDemandOptions {
pub allocation_strategy: Option<String>,
pub min_target_capacity: Option<i64>,
pub single_availability_zone: Option<bool>,
pub single_instance_type: Option<bool>,
}
struct OnDemandOptionsDeserializer;
impl OnDemandOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OnDemandOptions, XmlParseError> {
deserialize_elements::<_, OnDemandOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationStrategy" => {
obj.allocation_strategy =
Some(FleetOnDemandAllocationStrategyDeserializer::deserialize(
"allocationStrategy",
stack,
)?);
}
"minTargetCapacity" => {
obj.min_target_capacity = Some(IntegerDeserializer::deserialize(
"minTargetCapacity",
stack,
)?);
}
"singleAvailabilityZone" => {
obj.single_availability_zone = Some(BooleanDeserializer::deserialize(
"singleAvailabilityZone",
stack,
)?);
}
"singleInstanceType" => {
obj.single_instance_type = Some(BooleanDeserializer::deserialize(
"singleInstanceType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OnDemandOptionsRequest {
pub allocation_strategy: Option<String>,
pub min_target_capacity: Option<i64>,
pub single_availability_zone: Option<bool>,
pub single_instance_type: Option<bool>,
}
struct OnDemandOptionsRequestSerializer;
impl OnDemandOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &OnDemandOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocation_strategy {
params.put(&format!("{}{}", prefix, "AllocationStrategy"), &field_value);
}
if let Some(ref field_value) = obj.min_target_capacity {
params.put(&format!("{}{}", prefix, "MinTargetCapacity"), &field_value);
}
if let Some(ref field_value) = obj.single_availability_zone {
params.put(
&format!("{}{}", prefix, "SingleAvailabilityZone"),
&field_value,
);
}
if let Some(ref field_value) = obj.single_instance_type {
params.put(&format!("{}{}", prefix, "SingleInstanceType"), &field_value);
}
}
}
struct OwnerStringListSerializer;
impl OwnerStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct PaymentOptionDeserializer;
impl PaymentOptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PciId {
pub device_id: Option<String>,
pub subsystem_id: Option<String>,
pub subsystem_vendor_id: Option<String>,
pub vendor_id: Option<String>,
}
struct PciIdDeserializer;
impl PciIdDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<PciId, XmlParseError> {
deserialize_elements::<_, PciId, _>(tag_name, stack, |name, stack, obj| {
match name {
"DeviceId" => {
obj.device_id = Some(StringDeserializer::deserialize("DeviceId", stack)?);
}
"SubsystemId" => {
obj.subsystem_id = Some(StringDeserializer::deserialize("SubsystemId", stack)?);
}
"SubsystemVendorId" => {
obj.subsystem_vendor_id =
Some(StringDeserializer::deserialize("SubsystemVendorId", stack)?);
}
"VendorId" => {
obj.vendor_id = Some(StringDeserializer::deserialize("VendorId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PeeringConnectionOptions {
pub allow_dns_resolution_from_remote_vpc: Option<bool>,
pub allow_egress_from_local_classic_link_to_remote_vpc: Option<bool>,
pub allow_egress_from_local_vpc_to_remote_classic_link: Option<bool>,
}
struct PeeringConnectionOptionsDeserializer;
impl PeeringConnectionOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PeeringConnectionOptions, XmlParseError> {
deserialize_elements::<_, PeeringConnectionOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"allowDnsResolutionFromRemoteVpc" => {
obj.allow_dns_resolution_from_remote_vpc =
Some(BooleanDeserializer::deserialize(
"allowDnsResolutionFromRemoteVpc",
stack,
)?);
}
"allowEgressFromLocalClassicLinkToRemoteVpc" => {
obj.allow_egress_from_local_classic_link_to_remote_vpc =
Some(BooleanDeserializer::deserialize(
"allowEgressFromLocalClassicLinkToRemoteVpc",
stack,
)?);
}
"allowEgressFromLocalVpcToRemoteClassicLink" => {
obj.allow_egress_from_local_vpc_to_remote_classic_link =
Some(BooleanDeserializer::deserialize(
"allowEgressFromLocalVpcToRemoteClassicLink",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PeeringConnectionOptionsRequest {
pub allow_dns_resolution_from_remote_vpc: Option<bool>,
pub allow_egress_from_local_classic_link_to_remote_vpc: Option<bool>,
pub allow_egress_from_local_vpc_to_remote_classic_link: Option<bool>,
}
struct PeeringConnectionOptionsRequestSerializer;
impl PeeringConnectionOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PeeringConnectionOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allow_dns_resolution_from_remote_vpc {
params.put(
&format!("{}{}", prefix, "AllowDnsResolutionFromRemoteVpc"),
&field_value,
);
}
if let Some(ref field_value) = obj.allow_egress_from_local_classic_link_to_remote_vpc {
params.put(
&format!("{}{}", prefix, "AllowEgressFromLocalClassicLinkToRemoteVpc"),
&field_value,
);
}
if let Some(ref field_value) = obj.allow_egress_from_local_vpc_to_remote_classic_link {
params.put(
&format!("{}{}", prefix, "AllowEgressFromLocalVpcToRemoteClassicLink"),
&field_value,
);
}
}
}
struct PermissionGroupDeserializer;
impl PermissionGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Placement {
pub affinity: Option<String>,
pub availability_zone: Option<String>,
pub group_name: Option<String>,
pub host_id: Option<String>,
pub partition_number: Option<i64>,
pub spread_domain: Option<String>,
pub tenancy: Option<String>,
}
struct PlacementDeserializer;
impl PlacementDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Placement, XmlParseError> {
deserialize_elements::<_, Placement, _>(tag_name, stack, |name, stack, obj| {
match name {
"affinity" => {
obj.affinity = Some(StringDeserializer::deserialize("affinity", stack)?);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"hostId" => {
obj.host_id = Some(StringDeserializer::deserialize("hostId", stack)?);
}
"partitionNumber" => {
obj.partition_number =
Some(IntegerDeserializer::deserialize("partitionNumber", stack)?);
}
"spreadDomain" => {
obj.spread_domain =
Some(StringDeserializer::deserialize("spreadDomain", stack)?);
}
"tenancy" => {
obj.tenancy = Some(TenancyDeserializer::deserialize("tenancy", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PlacementSerializer;
impl PlacementSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Placement) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.affinity {
params.put(&format!("{}{}", prefix, "Affinity"), &field_value);
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.host_id {
params.put(&format!("{}{}", prefix, "HostId"), &field_value);
}
if let Some(ref field_value) = obj.partition_number {
params.put(&format!("{}{}", prefix, "PartitionNumber"), &field_value);
}
if let Some(ref field_value) = obj.spread_domain {
params.put(&format!("{}{}", prefix, "SpreadDomain"), &field_value);
}
if let Some(ref field_value) = obj.tenancy {
params.put(&format!("{}{}", prefix, "Tenancy"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PlacementGroup {
pub group_name: Option<String>,
pub partition_count: Option<i64>,
pub state: Option<String>,
pub strategy: Option<String>,
}
struct PlacementGroupDeserializer;
impl PlacementGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PlacementGroup, XmlParseError> {
deserialize_elements::<_, PlacementGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"partitionCount" => {
obj.partition_count =
Some(IntegerDeserializer::deserialize("partitionCount", stack)?);
}
"state" => {
obj.state = Some(PlacementGroupStateDeserializer::deserialize(
"state", stack,
)?);
}
"strategy" => {
obj.strategy = Some(PlacementStrategyDeserializer::deserialize(
"strategy", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PlacementGroupListDeserializer;
impl PlacementGroupListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PlacementGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PlacementGroupDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PlacementGroupStateDeserializer;
impl PlacementGroupStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PlacementGroupStringListSerializer;
impl PlacementGroupStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PlacementResponse {
pub group_name: Option<String>,
}
struct PlacementResponseDeserializer;
impl PlacementResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PlacementResponse, XmlParseError> {
deserialize_elements::<_, PlacementResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PlacementStrategyDeserializer;
impl PlacementStrategyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PlatformValuesDeserializer;
impl PlatformValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PortRange {
pub from: Option<i64>,
pub to: Option<i64>,
}
struct PortRangeDeserializer;
impl PortRangeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PortRange, XmlParseError> {
deserialize_elements::<_, PortRange, _>(tag_name, stack, |name, stack, obj| {
match name {
"from" => {
obj.from = Some(IntegerDeserializer::deserialize("from", stack)?);
}
"to" => {
obj.to = Some(IntegerDeserializer::deserialize("to", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PortRangeSerializer;
impl PortRangeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PortRange) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.from {
params.put(&format!("{}{}", prefix, "From"), &field_value);
}
if let Some(ref field_value) = obj.to {
params.put(&format!("{}{}", prefix, "To"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PrefixList {
pub cidrs: Option<Vec<String>>,
pub prefix_list_id: Option<String>,
pub prefix_list_name: Option<String>,
}
struct PrefixListDeserializer;
impl PrefixListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PrefixList, XmlParseError> {
deserialize_elements::<_, PrefixList, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidrSet" => {
obj.cidrs
.get_or_insert(vec![])
.extend(ValueStringListDeserializer::deserialize("cidrSet", stack)?);
}
"prefixListId" => {
obj.prefix_list_id =
Some(StringDeserializer::deserialize("prefixListId", stack)?);
}
"prefixListName" => {
obj.prefix_list_name =
Some(StringDeserializer::deserialize("prefixListName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PrefixListId {
pub description: Option<String>,
pub prefix_list_id: Option<String>,
}
struct PrefixListIdDeserializer;
impl PrefixListIdDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PrefixListId, XmlParseError> {
deserialize_elements::<_, PrefixListId, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"prefixListId" => {
obj.prefix_list_id =
Some(StringDeserializer::deserialize("prefixListId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PrefixListIdSerializer;
impl PrefixListIdSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PrefixListId) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.prefix_list_id {
params.put(&format!("{}{}", prefix, "PrefixListId"), &field_value);
}
}
}
struct PrefixListIdListDeserializer;
impl PrefixListIdListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PrefixListId>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PrefixListIdDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PrefixListIdListSerializer;
impl PrefixListIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<PrefixListId>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
PrefixListIdSerializer::serialize(params, &key, obj);
}
}
}
struct PrefixListIdSetDeserializer;
impl PrefixListIdSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PrefixListSetDeserializer;
impl PrefixListSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PrefixList>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PrefixListDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PriceSchedule {
pub active: Option<bool>,
pub currency_code: Option<String>,
pub price: Option<f64>,
pub term: Option<i64>,
}
struct PriceScheduleDeserializer;
impl PriceScheduleDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PriceSchedule, XmlParseError> {
deserialize_elements::<_, PriceSchedule, _>(tag_name, stack, |name, stack, obj| {
match name {
"active" => {
obj.active = Some(BooleanDeserializer::deserialize("active", stack)?);
}
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"price" => {
obj.price = Some(DoubleDeserializer::deserialize("price", stack)?);
}
"term" => {
obj.term = Some(LongDeserializer::deserialize("term", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PriceScheduleListDeserializer;
impl PriceScheduleListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PriceSchedule>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PriceScheduleDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PriceScheduleSpecification {
pub currency_code: Option<String>,
pub price: Option<f64>,
pub term: Option<i64>,
}
struct PriceScheduleSpecificationSerializer;
impl PriceScheduleSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PriceScheduleSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.currency_code {
params.put(&format!("{}{}", prefix, "CurrencyCode"), &field_value);
}
if let Some(ref field_value) = obj.price {
params.put(&format!("{}{}", prefix, "Price"), &field_value);
}
if let Some(ref field_value) = obj.term {
params.put(&format!("{}{}", prefix, "Term"), &field_value);
}
}
}
struct PriceScheduleSpecificationListSerializer;
impl PriceScheduleSpecificationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<PriceScheduleSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
PriceScheduleSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PricingDetail {
pub count: Option<i64>,
pub price: Option<f64>,
}
struct PricingDetailDeserializer;
impl PricingDetailDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PricingDetail, XmlParseError> {
deserialize_elements::<_, PricingDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"count" => {
obj.count = Some(IntegerDeserializer::deserialize("count", stack)?);
}
"price" => {
obj.price = Some(DoubleDeserializer::deserialize("price", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PricingDetailsListDeserializer;
impl PricingDetailsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PricingDetail>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PricingDetailDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PrincipalIdFormat {
pub arn: Option<String>,
pub statuses: Option<Vec<IdFormat>>,
}
struct PrincipalIdFormatDeserializer;
impl PrincipalIdFormatDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PrincipalIdFormat, XmlParseError> {
deserialize_elements::<_, PrincipalIdFormat, _>(tag_name, stack, |name, stack, obj| {
match name {
"arn" => {
obj.arn = Some(StringDeserializer::deserialize("arn", stack)?);
}
"statusSet" => {
obj.statuses
.get_or_insert(vec![])
.extend(IdFormatListDeserializer::deserialize("statusSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PrincipalIdFormatListDeserializer;
impl PrincipalIdFormatListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PrincipalIdFormat>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PrincipalIdFormatDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PrincipalTypeDeserializer;
impl PrincipalTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PrivateIpAddressConfigSetSerializer;
impl PrivateIpAddressConfigSetSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &Vec<ScheduledInstancesPrivateIpAddressConfig>,
) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ScheduledInstancesPrivateIpAddressConfigSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PrivateIpAddressSpecification {
pub primary: Option<bool>,
pub private_ip_address: Option<String>,
}
struct PrivateIpAddressSpecificationDeserializer;
impl PrivateIpAddressSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PrivateIpAddressSpecification, XmlParseError> {
deserialize_elements::<_, PrivateIpAddressSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"primary" => {
obj.primary = Some(BooleanDeserializer::deserialize("primary", stack)?);
}
"privateIpAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("privateIpAddress", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct PrivateIpAddressSpecificationSerializer;
impl PrivateIpAddressSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PrivateIpAddressSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.primary {
params.put(&format!("{}{}", prefix, "Primary"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
}
}
struct PrivateIpAddressSpecificationListDeserializer;
impl PrivateIpAddressSpecificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PrivateIpAddressSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PrivateIpAddressSpecificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PrivateIpAddressSpecificationListSerializer;
impl PrivateIpAddressSpecificationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<PrivateIpAddressSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
PrivateIpAddressSpecificationSerializer::serialize(params, &key, obj);
}
}
}
struct PrivateIpAddressStringListSerializer;
impl PrivateIpAddressStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ProductCode {
pub product_code_id: Option<String>,
pub product_code_type: Option<String>,
}
struct ProductCodeDeserializer;
impl ProductCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ProductCode, XmlParseError> {
deserialize_elements::<_, ProductCode, _>(tag_name, stack, |name, stack, obj| {
match name {
"productCode" => {
obj.product_code_id =
Some(StringDeserializer::deserialize("productCode", stack)?);
}
"type" => {
obj.product_code_type =
Some(ProductCodeValuesDeserializer::deserialize("type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ProductCodeListDeserializer;
impl ProductCodeListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ProductCode>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ProductCodeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ProductCodeStringListSerializer;
impl ProductCodeStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ProductCodeValuesDeserializer;
impl ProductCodeValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ProductDescriptionListSerializer;
impl ProductDescriptionListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PropagatingVgw {
pub gateway_id: Option<String>,
}
struct PropagatingVgwDeserializer;
impl PropagatingVgwDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PropagatingVgw, XmlParseError> {
deserialize_elements::<_, PropagatingVgw, _>(tag_name, stack, |name, stack, obj| {
match name {
"gatewayId" => {
obj.gateway_id = Some(StringDeserializer::deserialize("gatewayId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PropagatingVgwListDeserializer;
impl PropagatingVgwListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PropagatingVgw>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PropagatingVgwDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ProvisionByoipCidrRequest {
pub cidr: String,
pub cidr_authorization_context: Option<CidrAuthorizationContext>,
pub description: Option<String>,
pub dry_run: Option<bool>,
}
struct ProvisionByoipCidrRequestSerializer;
impl ProvisionByoipCidrRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ProvisionByoipCidrRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Cidr"), &obj.cidr);
if let Some(ref field_value) = obj.cidr_authorization_context {
CidrAuthorizationContextSerializer::serialize(
params,
&format!("{}{}", prefix, "CidrAuthorizationContext"),
field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ProvisionByoipCidrResult {
pub byoip_cidr: Option<ByoipCidr>,
}
struct ProvisionByoipCidrResultDeserializer;
impl ProvisionByoipCidrResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ProvisionByoipCidrResult, XmlParseError> {
deserialize_elements::<_, ProvisionByoipCidrResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"byoipCidr" => {
obj.byoip_cidr =
Some(ByoipCidrDeserializer::deserialize("byoipCidr", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ProvisionedBandwidth {
pub provision_time: Option<String>,
pub provisioned: Option<String>,
pub request_time: Option<String>,
pub requested: Option<String>,
pub status: Option<String>,
}
struct ProvisionedBandwidthDeserializer;
impl ProvisionedBandwidthDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ProvisionedBandwidth, XmlParseError> {
deserialize_elements::<_, ProvisionedBandwidth, _>(tag_name, stack, |name, stack, obj| {
match name {
"provisionTime" => {
obj.provision_time =
Some(DateTimeDeserializer::deserialize("provisionTime", stack)?);
}
"provisioned" => {
obj.provisioned = Some(StringDeserializer::deserialize("provisioned", stack)?);
}
"requestTime" => {
obj.request_time =
Some(DateTimeDeserializer::deserialize("requestTime", stack)?);
}
"requested" => {
obj.requested = Some(StringDeserializer::deserialize("requested", stack)?);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PublicIpStringListSerializer;
impl PublicIpStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PublicIpv4Pool {
pub description: Option<String>,
pub pool_address_ranges: Option<Vec<PublicIpv4PoolRange>>,
pub pool_id: Option<String>,
pub total_address_count: Option<i64>,
pub total_available_address_count: Option<i64>,
}
struct PublicIpv4PoolDeserializer;
impl PublicIpv4PoolDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublicIpv4Pool, XmlParseError> {
deserialize_elements::<_, PublicIpv4Pool, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"poolAddressRangeSet" => {
obj.pool_address_ranges.get_or_insert(vec![]).extend(
PublicIpv4PoolRangeSetDeserializer::deserialize(
"poolAddressRangeSet",
stack,
)?,
);
}
"poolId" => {
obj.pool_id = Some(StringDeserializer::deserialize("poolId", stack)?);
}
"totalAddressCount" => {
obj.total_address_count = Some(IntegerDeserializer::deserialize(
"totalAddressCount",
stack,
)?);
}
"totalAvailableAddressCount" => {
obj.total_available_address_count = Some(IntegerDeserializer::deserialize(
"totalAvailableAddressCount",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PublicIpv4PoolRange {
pub address_count: Option<i64>,
pub available_address_count: Option<i64>,
pub first_address: Option<String>,
pub last_address: Option<String>,
}
struct PublicIpv4PoolRangeDeserializer;
impl PublicIpv4PoolRangeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublicIpv4PoolRange, XmlParseError> {
deserialize_elements::<_, PublicIpv4PoolRange, _>(tag_name, stack, |name, stack, obj| {
match name {
"addressCount" => {
obj.address_count =
Some(IntegerDeserializer::deserialize("addressCount", stack)?);
}
"availableAddressCount" => {
obj.available_address_count = Some(IntegerDeserializer::deserialize(
"availableAddressCount",
stack,
)?);
}
"firstAddress" => {
obj.first_address =
Some(StringDeserializer::deserialize("firstAddress", stack)?);
}
"lastAddress" => {
obj.last_address = Some(StringDeserializer::deserialize("lastAddress", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PublicIpv4PoolRangeSetDeserializer;
impl PublicIpv4PoolRangeSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PublicIpv4PoolRange>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PublicIpv4PoolRangeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PublicIpv4PoolSetDeserializer;
impl PublicIpv4PoolSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PublicIpv4Pool>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PublicIpv4PoolDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Purchase {
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub host_id_set: Option<Vec<String>>,
pub host_reservation_id: Option<String>,
pub hourly_price: Option<String>,
pub instance_family: Option<String>,
pub payment_option: Option<String>,
pub upfront_price: Option<String>,
}
struct PurchaseDeserializer;
impl PurchaseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Purchase, XmlParseError> {
deserialize_elements::<_, Purchase, _>(tag_name, stack, |name, stack, obj| {
match name {
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("duration", stack)?);
}
"hostIdSet" => {
obj.host_id_set.get_or_insert(vec![]).extend(
ResponseHostIdSetDeserializer::deserialize("hostIdSet", stack)?,
);
}
"hostReservationId" => {
obj.host_reservation_id =
Some(StringDeserializer::deserialize("hostReservationId", stack)?);
}
"hourlyPrice" => {
obj.hourly_price = Some(StringDeserializer::deserialize("hourlyPrice", stack)?);
}
"instanceFamily" => {
obj.instance_family =
Some(StringDeserializer::deserialize("instanceFamily", stack)?);
}
"paymentOption" => {
obj.payment_option = Some(PaymentOptionDeserializer::deserialize(
"paymentOption",
stack,
)?);
}
"upfrontPrice" => {
obj.upfront_price =
Some(StringDeserializer::deserialize("upfrontPrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseHostReservationRequest {
pub client_token: Option<String>,
pub currency_code: Option<String>,
pub host_id_set: Vec<String>,
pub limit_price: Option<String>,
pub offering_id: String,
}
struct PurchaseHostReservationRequestSerializer;
impl PurchaseHostReservationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PurchaseHostReservationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.currency_code {
params.put(&format!("{}{}", prefix, "CurrencyCode"), &field_value);
}
RequestHostIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "HostIdSet"),
&obj.host_id_set,
);
if let Some(ref field_value) = obj.limit_price {
params.put(&format!("{}{}", prefix, "LimitPrice"), &field_value);
}
params.put(&format!("{}{}", prefix, "OfferingId"), &obj.offering_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseHostReservationResult {
pub client_token: Option<String>,
pub currency_code: Option<String>,
pub purchase: Option<Vec<Purchase>>,
pub total_hourly_price: Option<String>,
pub total_upfront_price: Option<String>,
}
struct PurchaseHostReservationResultDeserializer;
impl PurchaseHostReservationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PurchaseHostReservationResult, XmlParseError> {
deserialize_elements::<_, PurchaseHostReservationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"purchase" => {
obj.purchase
.get_or_insert(vec![])
.extend(PurchaseSetDeserializer::deserialize("purchase", stack)?);
}
"totalHourlyPrice" => {
obj.total_hourly_price =
Some(StringDeserializer::deserialize("totalHourlyPrice", stack)?);
}
"totalUpfrontPrice" => {
obj.total_upfront_price =
Some(StringDeserializer::deserialize("totalUpfrontPrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseRequest {
pub instance_count: i64,
pub purchase_token: String,
}
struct PurchaseRequestSerializer;
impl PurchaseRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PurchaseRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "InstanceCount"),
&obj.instance_count,
);
params.put(
&format!("{}{}", prefix, "PurchaseToken"),
&obj.purchase_token,
);
}
}
struct PurchaseRequestSetSerializer;
impl PurchaseRequestSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<PurchaseRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
PurchaseRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseReservedInstancesOfferingRequest {
pub dry_run: Option<bool>,
pub instance_count: i64,
pub limit_price: Option<ReservedInstanceLimitPrice>,
pub reserved_instances_offering_id: String,
}
struct PurchaseReservedInstancesOfferingRequestSerializer;
impl PurchaseReservedInstancesOfferingRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PurchaseReservedInstancesOfferingRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "InstanceCount"),
&obj.instance_count,
);
if let Some(ref field_value) = obj.limit_price {
ReservedInstanceLimitPriceSerializer::serialize(
params,
&format!("{}{}", prefix, "LimitPrice"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReservedInstancesOfferingId"),
&obj.reserved_instances_offering_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseReservedInstancesOfferingResult {
pub reserved_instances_id: Option<String>,
}
struct PurchaseReservedInstancesOfferingResultDeserializer;
impl PurchaseReservedInstancesOfferingResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PurchaseReservedInstancesOfferingResult, XmlParseError> {
deserialize_elements::<_, PurchaseReservedInstancesOfferingResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesId" => {
obj.reserved_instances_id = Some(StringDeserializer::deserialize(
"reservedInstancesId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseScheduledInstancesRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub purchase_requests: Vec<PurchaseRequest>,
}
struct PurchaseScheduledInstancesRequestSerializer;
impl PurchaseScheduledInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PurchaseScheduledInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
PurchaseRequestSetSerializer::serialize(
params,
&format!("{}{}", prefix, "PurchaseRequest"),
&obj.purchase_requests,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseScheduledInstancesResult {
pub scheduled_instance_set: Option<Vec<ScheduledInstance>>,
}
struct PurchaseScheduledInstancesResultDeserializer;
impl PurchaseScheduledInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PurchaseScheduledInstancesResult, XmlParseError> {
deserialize_elements::<_, PurchaseScheduledInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"scheduledInstanceSet" => {
obj.scheduled_instance_set.get_or_insert(vec![]).extend(
PurchasedScheduledInstanceSetDeserializer::deserialize(
"scheduledInstanceSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct PurchaseSetDeserializer;
impl PurchaseSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Purchase>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(PurchaseDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct PurchasedScheduledInstanceSetDeserializer;
impl PurchasedScheduledInstanceSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ScheduledInstance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ScheduledInstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RIProductDescriptionDeserializer;
impl RIProductDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ReasonCodesListSerializer;
impl ReasonCodesListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RebootInstancesRequest {
pub dry_run: Option<bool>,
pub instance_ids: Vec<String>,
}
struct RebootInstancesRequestSerializer;
impl RebootInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RebootInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instance_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RecurringCharge {
pub amount: Option<f64>,
pub frequency: Option<String>,
}
struct RecurringChargeDeserializer;
impl RecurringChargeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RecurringCharge, XmlParseError> {
deserialize_elements::<_, RecurringCharge, _>(tag_name, stack, |name, stack, obj| {
match name {
"amount" => {
obj.amount = Some(DoubleDeserializer::deserialize("amount", stack)?);
}
"frequency" => {
obj.frequency = Some(RecurringChargeFrequencyDeserializer::deserialize(
"frequency",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RecurringChargeFrequencyDeserializer;
impl RecurringChargeFrequencyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct RecurringChargesListDeserializer;
impl RecurringChargesListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RecurringCharge>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(RecurringChargeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Region {
pub endpoint: Option<String>,
pub region_name: Option<String>,
}
struct RegionDeserializer;
impl RegionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Region, XmlParseError> {
deserialize_elements::<_, Region, _>(tag_name, stack, |name, stack, obj| {
match name {
"regionEndpoint" => {
obj.endpoint = Some(StringDeserializer::deserialize("regionEndpoint", stack)?);
}
"regionName" => {
obj.region_name = Some(StringDeserializer::deserialize("regionName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RegionListDeserializer;
impl RegionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Region>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(RegionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RegionNameStringListSerializer;
impl RegionNameStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RegisterImageRequest {
pub architecture: Option<String>,
pub billing_products: Option<Vec<String>>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub description: Option<String>,
pub dry_run: Option<bool>,
pub ena_support: Option<bool>,
pub image_location: Option<String>,
pub kernel_id: Option<String>,
pub name: String,
pub ramdisk_id: Option<String>,
pub root_device_name: Option<String>,
pub sriov_net_support: Option<String>,
pub virtualization_type: Option<String>,
}
struct RegisterImageRequestSerializer;
impl RegisterImageRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RegisterImageRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.architecture {
params.put(&format!("{}{}", prefix, "Architecture"), &field_value);
}
if let Some(ref field_value) = obj.billing_products {
BillingProductListSerializer::serialize(
params,
&format!("{}{}", prefix, "BillingProduct"),
field_value,
);
}
if let Some(ref field_value) = obj.block_device_mappings {
BlockDeviceMappingRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.ena_support {
params.put(&format!("{}{}", prefix, "EnaSupport"), &field_value);
}
if let Some(ref field_value) = obj.image_location {
params.put(&format!("{}{}", prefix, "ImageLocation"), &field_value);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
if let Some(ref field_value) = obj.ramdisk_id {
params.put(&format!("{}{}", prefix, "RamdiskId"), &field_value);
}
if let Some(ref field_value) = obj.root_device_name {
params.put(&format!("{}{}", prefix, "RootDeviceName"), &field_value);
}
if let Some(ref field_value) = obj.sriov_net_support {
params.put(&format!("{}{}", prefix, "SriovNetSupport"), &field_value);
}
if let Some(ref field_value) = obj.virtualization_type {
params.put(&format!("{}{}", prefix, "VirtualizationType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RegisterImageResult {
pub image_id: Option<String>,
}
struct RegisterImageResultDeserializer;
impl RegisterImageResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RegisterImageResult, XmlParseError> {
deserialize_elements::<_, RegisterImageResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RejectTransitGatewayVpcAttachmentRequest {
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: String,
}
struct RejectTransitGatewayVpcAttachmentRequestSerializer;
impl RejectTransitGatewayVpcAttachmentRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RejectTransitGatewayVpcAttachmentRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&obj.transit_gateway_attachment_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RejectTransitGatewayVpcAttachmentResult {
pub transit_gateway_vpc_attachment: Option<TransitGatewayVpcAttachment>,
}
struct RejectTransitGatewayVpcAttachmentResultDeserializer;
impl RejectTransitGatewayVpcAttachmentResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RejectTransitGatewayVpcAttachmentResult, XmlParseError> {
deserialize_elements::<_, RejectTransitGatewayVpcAttachmentResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"transitGatewayVpcAttachment" => {
obj.transit_gateway_vpc_attachment =
Some(TransitGatewayVpcAttachmentDeserializer::deserialize(
"transitGatewayVpcAttachment",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RejectVpcEndpointConnectionsRequest {
pub dry_run: Option<bool>,
pub service_id: String,
pub vpc_endpoint_ids: Vec<String>,
}
struct RejectVpcEndpointConnectionsRequestSerializer;
impl RejectVpcEndpointConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RejectVpcEndpointConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "ServiceId"), &obj.service_id);
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcEndpointId"),
&obj.vpc_endpoint_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RejectVpcEndpointConnectionsResult {
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct RejectVpcEndpointConnectionsResultDeserializer;
impl RejectVpcEndpointConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RejectVpcEndpointConnectionsResult, XmlParseError> {
deserialize_elements::<_, RejectVpcEndpointConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemSetDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RejectVpcPeeringConnectionRequest {
pub dry_run: Option<bool>,
pub vpc_peering_connection_id: String,
}
struct RejectVpcPeeringConnectionRequestSerializer;
impl RejectVpcPeeringConnectionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RejectVpcPeeringConnectionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&obj.vpc_peering_connection_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RejectVpcPeeringConnectionResult {
pub return_: Option<bool>,
}
struct RejectVpcPeeringConnectionResultDeserializer;
impl RejectVpcPeeringConnectionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RejectVpcPeeringConnectionResult, XmlParseError> {
deserialize_elements::<_, RejectVpcPeeringConnectionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReleaseAddressRequest {
pub allocation_id: Option<String>,
pub dry_run: Option<bool>,
pub public_ip: Option<String>,
}
struct ReleaseAddressRequestSerializer;
impl ReleaseAddressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReleaseAddressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocation_id {
params.put(&format!("{}{}", prefix, "AllocationId"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.public_ip {
params.put(&format!("{}{}", prefix, "PublicIp"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReleaseHostsRequest {
pub host_ids: Vec<String>,
}
struct ReleaseHostsRequestSerializer;
impl ReleaseHostsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReleaseHostsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
RequestHostIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "HostId"),
&obj.host_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReleaseHostsResult {
pub successful: Option<Vec<String>>,
pub unsuccessful: Option<Vec<UnsuccessfulItem>>,
}
struct ReleaseHostsResultDeserializer;
impl ReleaseHostsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReleaseHostsResult, XmlParseError> {
deserialize_elements::<_, ReleaseHostsResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"successful" => {
obj.successful.get_or_insert(vec![]).extend(
ResponseHostIdListDeserializer::deserialize("successful", stack)?,
);
}
"unsuccessful" => {
obj.unsuccessful.get_or_insert(vec![]).extend(
UnsuccessfulItemListDeserializer::deserialize("unsuccessful", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceIamInstanceProfileAssociationRequest {
pub association_id: String,
pub iam_instance_profile: IamInstanceProfileSpecification,
}
struct ReplaceIamInstanceProfileAssociationRequestSerializer;
impl ReplaceIamInstanceProfileAssociationRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ReplaceIamInstanceProfileAssociationRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
IamInstanceProfileSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
&obj.iam_instance_profile,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceIamInstanceProfileAssociationResult {
pub iam_instance_profile_association: Option<IamInstanceProfileAssociation>,
}
struct ReplaceIamInstanceProfileAssociationResultDeserializer;
impl ReplaceIamInstanceProfileAssociationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplaceIamInstanceProfileAssociationResult, XmlParseError> {
deserialize_elements::<_, ReplaceIamInstanceProfileAssociationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"iamInstanceProfileAssociation" => {
obj.iam_instance_profile_association =
Some(IamInstanceProfileAssociationDeserializer::deserialize(
"iamInstanceProfileAssociation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceNetworkAclAssociationRequest {
pub association_id: String,
pub dry_run: Option<bool>,
pub network_acl_id: String,
}
struct ReplaceNetworkAclAssociationRequestSerializer;
impl ReplaceNetworkAclAssociationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReplaceNetworkAclAssociationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkAclId"),
&obj.network_acl_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceNetworkAclAssociationResult {
pub new_association_id: Option<String>,
}
struct ReplaceNetworkAclAssociationResultDeserializer;
impl ReplaceNetworkAclAssociationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplaceNetworkAclAssociationResult, XmlParseError> {
deserialize_elements::<_, ReplaceNetworkAclAssociationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"newAssociationId" => {
obj.new_association_id =
Some(StringDeserializer::deserialize("newAssociationId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceNetworkAclEntryRequest {
pub cidr_block: Option<String>,
pub dry_run: Option<bool>,
pub egress: bool,
pub icmp_type_code: Option<IcmpTypeCode>,
pub ipv_6_cidr_block: Option<String>,
pub network_acl_id: String,
pub port_range: Option<PortRange>,
pub protocol: String,
pub rule_action: String,
pub rule_number: i64,
}
struct ReplaceNetworkAclEntryRequestSerializer;
impl ReplaceNetworkAclEntryRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReplaceNetworkAclEntryRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_block {
params.put(&format!("{}{}", prefix, "CidrBlock"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "Egress"), &obj.egress);
if let Some(ref field_value) = obj.icmp_type_code {
IcmpTypeCodeSerializer::serialize(
params,
&format!("{}{}", prefix, "Icmp"),
field_value,
);
}
if let Some(ref field_value) = obj.ipv_6_cidr_block {
params.put(&format!("{}{}", prefix, "Ipv6CidrBlock"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkAclId"),
&obj.network_acl_id,
);
if let Some(ref field_value) = obj.port_range {
PortRangeSerializer::serialize(
params,
&format!("{}{}", prefix, "PortRange"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "Protocol"), &obj.protocol);
params.put(&format!("{}{}", prefix, "RuleAction"), &obj.rule_action);
params.put(&format!("{}{}", prefix, "RuleNumber"), &obj.rule_number);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceRouteRequest {
pub destination_cidr_block: Option<String>,
pub destination_ipv_6_cidr_block: Option<String>,
pub dry_run: Option<bool>,
pub egress_only_internet_gateway_id: Option<String>,
pub gateway_id: Option<String>,
pub instance_id: Option<String>,
pub nat_gateway_id: Option<String>,
pub network_interface_id: Option<String>,
pub route_table_id: String,
pub transit_gateway_id: Option<String>,
pub vpc_peering_connection_id: Option<String>,
}
struct ReplaceRouteRequestSerializer;
impl ReplaceRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReplaceRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.destination_cidr_block {
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.destination_ipv_6_cidr_block {
params.put(
&format!("{}{}", prefix, "DestinationIpv6CidrBlock"),
&field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.egress_only_internet_gateway_id {
params.put(
&format!("{}{}", prefix, "EgressOnlyInternetGatewayId"),
&field_value,
);
}
if let Some(ref field_value) = obj.gateway_id {
params.put(&format!("{}{}", prefix, "GatewayId"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
if let Some(ref field_value) = obj.nat_gateway_id {
params.put(&format!("{}{}", prefix, "NatGatewayId"), &field_value);
}
if let Some(ref field_value) = obj.network_interface_id {
params.put(&format!("{}{}", prefix, "NetworkInterfaceId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
if let Some(ref field_value) = obj.transit_gateway_id {
params.put(&format!("{}{}", prefix, "TransitGatewayId"), &field_value);
}
if let Some(ref field_value) = obj.vpc_peering_connection_id {
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceRouteTableAssociationRequest {
pub association_id: String,
pub dry_run: Option<bool>,
pub route_table_id: String,
}
struct ReplaceRouteTableAssociationRequestSerializer;
impl ReplaceRouteTableAssociationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReplaceRouteTableAssociationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AssociationId"),
&obj.association_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RouteTableId"),
&obj.route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceRouteTableAssociationResult {
pub new_association_id: Option<String>,
}
struct ReplaceRouteTableAssociationResultDeserializer;
impl ReplaceRouteTableAssociationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplaceRouteTableAssociationResult, XmlParseError> {
deserialize_elements::<_, ReplaceRouteTableAssociationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"newAssociationId" => {
obj.new_association_id =
Some(StringDeserializer::deserialize("newAssociationId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceTransitGatewayRouteRequest {
pub blackhole: Option<bool>,
pub destination_cidr_block: String,
pub dry_run: Option<bool>,
pub transit_gateway_attachment_id: Option<String>,
pub transit_gateway_route_table_id: String,
}
struct ReplaceTransitGatewayRouteRequestSerializer;
impl ReplaceTransitGatewayRouteRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReplaceTransitGatewayRouteRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.blackhole {
params.put(&format!("{}{}", prefix, "Blackhole"), &field_value);
}
params.put(
&format!("{}{}", prefix, "DestinationCidrBlock"),
&obj.destination_cidr_block,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.transit_gateway_attachment_id {
params.put(
&format!("{}{}", prefix, "TransitGatewayAttachmentId"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReplaceTransitGatewayRouteResult {
pub route: Option<TransitGatewayRoute>,
}
struct ReplaceTransitGatewayRouteResultDeserializer;
impl ReplaceTransitGatewayRouteResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplaceTransitGatewayRouteResult, XmlParseError> {
deserialize_elements::<_, ReplaceTransitGatewayRouteResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"route" => {
obj.route = Some(TransitGatewayRouteDeserializer::deserialize(
"route", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReportInstanceStatusRequest {
pub description: Option<String>,
pub dry_run: Option<bool>,
pub end_time: Option<String>,
pub instances: Vec<String>,
pub reason_codes: Vec<String>,
pub start_time: Option<String>,
pub status: String,
}
struct ReportInstanceStatusRequestSerializer;
impl ReportInstanceStatusRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReportInstanceStatusRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instances,
);
ReasonCodesListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReasonCode"),
&obj.reason_codes,
);
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
params.put(&format!("{}{}", prefix, "Status"), &obj.status);
}
}
struct RequestHostIdListSerializer;
impl RequestHostIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct RequestHostIdSetSerializer;
impl RequestHostIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RequestLaunchTemplateData {
pub block_device_mappings: Option<Vec<LaunchTemplateBlockDeviceMappingRequest>>,
pub capacity_reservation_specification:
Option<LaunchTemplateCapacityReservationSpecificationRequest>,
pub cpu_options: Option<LaunchTemplateCpuOptionsRequest>,
pub credit_specification: Option<CreditSpecificationRequest>,
pub disable_api_termination: Option<bool>,
pub ebs_optimized: Option<bool>,
pub elastic_gpu_specifications: Option<Vec<ElasticGpuSpecification>>,
pub elastic_inference_accelerators: Option<Vec<LaunchTemplateElasticInferenceAccelerator>>,
pub hibernation_options: Option<LaunchTemplateHibernationOptionsRequest>,
pub iam_instance_profile: Option<LaunchTemplateIamInstanceProfileSpecificationRequest>,
pub image_id: Option<String>,
pub instance_initiated_shutdown_behavior: Option<String>,
pub instance_market_options: Option<LaunchTemplateInstanceMarketOptionsRequest>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub license_specifications: Option<Vec<LaunchTemplateLicenseConfigurationRequest>>,
pub monitoring: Option<LaunchTemplatesMonitoringRequest>,
pub network_interfaces: Option<Vec<LaunchTemplateInstanceNetworkInterfaceSpecificationRequest>>,
pub placement: Option<LaunchTemplatePlacementRequest>,
pub ram_disk_id: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub security_groups: Option<Vec<String>>,
pub tag_specifications: Option<Vec<LaunchTemplateTagSpecificationRequest>>,
pub user_data: Option<String>,
}
struct RequestLaunchTemplateDataSerializer;
impl RequestLaunchTemplateDataSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RequestLaunchTemplateData) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.block_device_mappings {
LaunchTemplateBlockDeviceMappingRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.capacity_reservation_specification {
LaunchTemplateCapacityReservationSpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "CapacityReservationSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.cpu_options {
LaunchTemplateCpuOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "CpuOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.credit_specification {
CreditSpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "CreditSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.disable_api_termination {
params.put(
&format!("{}{}", prefix, "DisableApiTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(&format!("{}{}", prefix, "EbsOptimized"), &field_value);
}
if let Some(ref field_value) = obj.elastic_gpu_specifications {
ElasticGpuSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "ElasticGpuSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.elastic_inference_accelerators {
LaunchTemplateElasticInferenceAcceleratorListSerializer::serialize(
params,
&format!("{}{}", prefix, "ElasticInferenceAccelerator"),
field_value,
);
}
if let Some(ref field_value) = obj.hibernation_options {
LaunchTemplateHibernationOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "HibernationOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.iam_instance_profile {
LaunchTemplateIamInstanceProfileSpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
field_value,
);
}
if let Some(ref field_value) = obj.image_id {
params.put(&format!("{}{}", prefix, "ImageId"), &field_value);
}
if let Some(ref field_value) = obj.instance_initiated_shutdown_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInitiatedShutdownBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_market_options {
LaunchTemplateInstanceMarketOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceMarketOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
if let Some(ref field_value) = obj.key_name {
params.put(&format!("{}{}", prefix, "KeyName"), &field_value);
}
if let Some(ref field_value) = obj.license_specifications {
LaunchTemplateLicenseSpecificationListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "LicenseSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.monitoring {
LaunchTemplatesMonitoringRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Monitoring"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interfaces {
LaunchTemplateInstanceNetworkInterfaceSpecificationRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterface"),
field_value,
);
}
if let Some(ref field_value) = obj.placement {
LaunchTemplatePlacementRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.ram_disk_id {
params.put(&format!("{}{}", prefix, "RamDiskId"), &field_value);
}
if let Some(ref field_value) = obj.security_group_ids {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.security_groups {
SecurityGroupStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_specifications {
LaunchTemplateTagSpecificationRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.user_data {
params.put(&format!("{}{}", prefix, "UserData"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RequestSpotFleetRequest {
pub dry_run: Option<bool>,
pub spot_fleet_request_config: SpotFleetRequestConfigData,
}
struct RequestSpotFleetRequestSerializer;
impl RequestSpotFleetRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RequestSpotFleetRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
SpotFleetRequestConfigDataSerializer::serialize(
params,
&format!("{}{}", prefix, "SpotFleetRequestConfig"),
&obj.spot_fleet_request_config,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RequestSpotFleetResponse {
pub spot_fleet_request_id: Option<String>,
}
struct RequestSpotFleetResponseDeserializer;
impl RequestSpotFleetResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RequestSpotFleetResponse, XmlParseError> {
deserialize_elements::<_, RequestSpotFleetResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"spotFleetRequestId" => {
obj.spot_fleet_request_id = Some(StringDeserializer::deserialize(
"spotFleetRequestId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RequestSpotInstancesRequest {
pub availability_zone_group: Option<String>,
pub block_duration_minutes: Option<i64>,
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub instance_count: Option<i64>,
pub instance_interruption_behavior: Option<String>,
pub launch_group: Option<String>,
pub launch_specification: Option<RequestSpotLaunchSpecification>,
pub spot_price: Option<String>,
pub type_: Option<String>,
pub valid_from: Option<String>,
pub valid_until: Option<String>,
}
struct RequestSpotInstancesRequestSerializer;
impl RequestSpotInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RequestSpotInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone_group {
params.put(
&format!("{}{}", prefix, "AvailabilityZoneGroup"),
&field_value,
);
}
if let Some(ref field_value) = obj.block_duration_minutes {
params.put(
&format!("{}{}", prefix, "BlockDurationMinutes"),
&field_value,
);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.instance_count {
params.put(&format!("{}{}", prefix, "InstanceCount"), &field_value);
}
if let Some(ref field_value) = obj.instance_interruption_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInterruptionBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.launch_group {
params.put(&format!("{}{}", prefix, "LaunchGroup"), &field_value);
}
if let Some(ref field_value) = obj.launch_specification {
RequestSpotLaunchSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.spot_price {
params.put(&format!("{}{}", prefix, "SpotPrice"), &field_value);
}
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.valid_from {
params.put(&format!("{}{}", prefix, "ValidFrom"), &field_value);
}
if let Some(ref field_value) = obj.valid_until {
params.put(&format!("{}{}", prefix, "ValidUntil"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RequestSpotInstancesResult {
pub spot_instance_requests: Option<Vec<SpotInstanceRequest>>,
}
struct RequestSpotInstancesResultDeserializer;
impl RequestSpotInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RequestSpotInstancesResult, XmlParseError> {
deserialize_elements::<_, RequestSpotInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"spotInstanceRequestSet" => {
obj.spot_instance_requests.get_or_insert(vec![]).extend(
SpotInstanceRequestListDeserializer::deserialize(
"spotInstanceRequestSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RequestSpotLaunchSpecification {
pub addressing_type: Option<String>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub ebs_optimized: Option<bool>,
pub iam_instance_profile: Option<IamInstanceProfileSpecification>,
pub image_id: Option<String>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub monitoring: Option<RunInstancesMonitoringEnabled>,
pub network_interfaces: Option<Vec<InstanceNetworkInterfaceSpecification>>,
pub placement: Option<SpotPlacement>,
pub ramdisk_id: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub security_groups: Option<Vec<String>>,
pub subnet_id: Option<String>,
pub user_data: Option<String>,
}
struct RequestSpotLaunchSpecificationSerializer;
impl RequestSpotLaunchSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RequestSpotLaunchSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.addressing_type {
params.put(&format!("{}{}", prefix, "AddressingType"), &field_value);
}
if let Some(ref field_value) = obj.block_device_mappings {
BlockDeviceMappingListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(&format!("{}{}", prefix, "EbsOptimized"), &field_value);
}
if let Some(ref field_value) = obj.iam_instance_profile {
IamInstanceProfileSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
field_value,
);
}
if let Some(ref field_value) = obj.image_id {
params.put(&format!("{}{}", prefix, "ImageId"), &field_value);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
if let Some(ref field_value) = obj.key_name {
params.put(&format!("{}{}", prefix, "KeyName"), &field_value);
}
if let Some(ref field_value) = obj.monitoring {
RunInstancesMonitoringEnabledSerializer::serialize(
params,
&format!("{}{}", prefix, "Monitoring"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interfaces {
InstanceNetworkInterfaceSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterface"),
field_value,
);
}
if let Some(ref field_value) = obj.placement {
SpotPlacementSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.ramdisk_id {
params.put(&format!("{}{}", prefix, "RamdiskId"), &field_value);
}
if let Some(ref field_value) = obj.security_group_ids {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.security_groups {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.user_data {
params.put(&format!("{}{}", prefix, "UserData"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Reservation {
pub groups: Option<Vec<GroupIdentifier>>,
pub instances: Option<Vec<Instance>>,
pub owner_id: Option<String>,
pub requester_id: Option<String>,
pub reservation_id: Option<String>,
}
struct ReservationDeserializer;
impl ReservationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Reservation, XmlParseError> {
deserialize_elements::<_, Reservation, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"instancesSet" => {
obj.instances.get_or_insert(vec![]).extend(
InstanceListDeserializer::deserialize("instancesSet", stack)?,
);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"requesterId" => {
obj.requester_id = Some(StringDeserializer::deserialize("requesterId", stack)?);
}
"reservationId" => {
obj.reservation_id =
Some(StringDeserializer::deserialize("reservationId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ReservationListDeserializer;
impl ReservationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Reservation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservationDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ReservationStateDeserializer;
impl ReservationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservationValue {
pub hourly_price: Option<String>,
pub remaining_total_value: Option<String>,
pub remaining_upfront_value: Option<String>,
}
struct ReservationValueDeserializer;
impl ReservationValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservationValue, XmlParseError> {
deserialize_elements::<_, ReservationValue, _>(tag_name, stack, |name, stack, obj| {
match name {
"hourlyPrice" => {
obj.hourly_price = Some(StringDeserializer::deserialize("hourlyPrice", stack)?);
}
"remainingTotalValue" => {
obj.remaining_total_value = Some(StringDeserializer::deserialize(
"remainingTotalValue",
stack,
)?);
}
"remainingUpfrontValue" => {
obj.remaining_upfront_value = Some(StringDeserializer::deserialize(
"remainingUpfrontValue",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ReservedInstanceIdSetSerializer;
impl ReservedInstanceIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstanceLimitPrice {
pub amount: Option<f64>,
pub currency_code: Option<String>,
}
struct ReservedInstanceLimitPriceSerializer;
impl ReservedInstanceLimitPriceSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReservedInstanceLimitPrice) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.amount {
params.put(&format!("{}{}", prefix, "Amount"), &field_value);
}
if let Some(ref field_value) = obj.currency_code {
params.put(&format!("{}{}", prefix, "CurrencyCode"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstanceReservationValue {
pub reservation_value: Option<ReservationValue>,
pub reserved_instance_id: Option<String>,
}
struct ReservedInstanceReservationValueDeserializer;
impl ReservedInstanceReservationValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstanceReservationValue, XmlParseError> {
deserialize_elements::<_, ReservedInstanceReservationValue, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservationValue" => {
obj.reservation_value = Some(ReservationValueDeserializer::deserialize(
"reservationValue",
stack,
)?);
}
"reservedInstanceId" => {
obj.reserved_instance_id = Some(StringDeserializer::deserialize(
"reservedInstanceId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ReservedInstanceReservationValueSetDeserializer;
impl ReservedInstanceReservationValueSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstanceReservationValue>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservedInstanceReservationValueDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ReservedInstanceStateDeserializer;
impl ReservedInstanceStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstances {
pub availability_zone: Option<String>,
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub end: Option<String>,
pub fixed_price: Option<f32>,
pub instance_count: Option<i64>,
pub instance_tenancy: Option<String>,
pub instance_type: Option<String>,
pub offering_class: Option<String>,
pub offering_type: Option<String>,
pub product_description: Option<String>,
pub recurring_charges: Option<Vec<RecurringCharge>>,
pub reserved_instances_id: Option<String>,
pub scope: Option<String>,
pub start: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub usage_price: Option<f32>,
}
struct ReservedInstancesDeserializer;
impl ReservedInstancesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstances, XmlParseError> {
deserialize_elements::<_, ReservedInstances, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"duration" => {
obj.duration = Some(LongDeserializer::deserialize("duration", stack)?);
}
"end" => {
obj.end = Some(DateTimeDeserializer::deserialize("end", stack)?);
}
"fixedPrice" => {
obj.fixed_price = Some(FloatDeserializer::deserialize("fixedPrice", stack)?);
}
"instanceCount" => {
obj.instance_count =
Some(IntegerDeserializer::deserialize("instanceCount", stack)?);
}
"instanceTenancy" => {
obj.instance_tenancy =
Some(TenancyDeserializer::deserialize("instanceTenancy", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"offeringClass" => {
obj.offering_class = Some(OfferingClassTypeDeserializer::deserialize(
"offeringClass",
stack,
)?);
}
"offeringType" => {
obj.offering_type = Some(OfferingTypeValuesDeserializer::deserialize(
"offeringType",
stack,
)?);
}
"productDescription" => {
obj.product_description = Some(RIProductDescriptionDeserializer::deserialize(
"productDescription",
stack,
)?);
}
"recurringCharges" => {
obj.recurring_charges.get_or_insert(vec![]).extend(
RecurringChargesListDeserializer::deserialize("recurringCharges", stack)?,
);
}
"reservedInstancesId" => {
obj.reserved_instances_id = Some(StringDeserializer::deserialize(
"reservedInstancesId",
stack,
)?);
}
"scope" => {
obj.scope = Some(ScopeDeserializer::deserialize("scope", stack)?);
}
"start" => {
obj.start = Some(DateTimeDeserializer::deserialize("start", stack)?);
}
"state" => {
obj.state = Some(ReservedInstanceStateDeserializer::deserialize(
"state", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"usagePrice" => {
obj.usage_price = Some(FloatDeserializer::deserialize("usagePrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstancesConfiguration {
pub availability_zone: Option<String>,
pub instance_count: Option<i64>,
pub instance_type: Option<String>,
pub platform: Option<String>,
pub scope: Option<String>,
}
struct ReservedInstancesConfigurationDeserializer;
impl ReservedInstancesConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstancesConfiguration, XmlParseError> {
deserialize_elements::<_, ReservedInstancesConfiguration, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"instanceCount" => {
obj.instance_count =
Some(IntegerDeserializer::deserialize("instanceCount", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"platform" => {
obj.platform = Some(StringDeserializer::deserialize("platform", stack)?);
}
"scope" => {
obj.scope = Some(ScopeDeserializer::deserialize("scope", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ReservedInstancesConfigurationSerializer;
impl ReservedInstancesConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReservedInstancesConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.instance_count {
params.put(&format!("{}{}", prefix, "InstanceCount"), &field_value);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.platform {
params.put(&format!("{}{}", prefix, "Platform"), &field_value);
}
if let Some(ref field_value) = obj.scope {
params.put(&format!("{}{}", prefix, "Scope"), &field_value);
}
}
}
struct ReservedInstancesConfigurationListSerializer;
impl ReservedInstancesConfigurationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ReservedInstancesConfiguration>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ReservedInstancesConfigurationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstancesId {
pub reserved_instances_id: Option<String>,
}
struct ReservedInstancesIdDeserializer;
impl ReservedInstancesIdDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstancesId, XmlParseError> {
deserialize_elements::<_, ReservedInstancesId, _>(tag_name, stack, |name, stack, obj| {
match name {
"reservedInstancesId" => {
obj.reserved_instances_id = Some(StringDeserializer::deserialize(
"reservedInstancesId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ReservedInstancesIdStringListSerializer;
impl ReservedInstancesIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ReservedInstancesListDeserializer;
impl ReservedInstancesListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstances>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservedInstancesDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstancesListing {
pub client_token: Option<String>,
pub create_date: Option<String>,
pub instance_counts: Option<Vec<InstanceCount>>,
pub price_schedules: Option<Vec<PriceSchedule>>,
pub reserved_instances_id: Option<String>,
pub reserved_instances_listing_id: Option<String>,
pub status: Option<String>,
pub status_message: Option<String>,
pub tags: Option<Vec<Tag>>,
pub update_date: Option<String>,
}
struct ReservedInstancesListingDeserializer;
impl ReservedInstancesListingDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstancesListing, XmlParseError> {
deserialize_elements::<_, ReservedInstancesListing, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"createDate" => {
obj.create_date =
Some(DateTimeDeserializer::deserialize("createDate", stack)?);
}
"instanceCounts" => {
obj.instance_counts.get_or_insert(vec![]).extend(
InstanceCountListDeserializer::deserialize("instanceCounts", stack)?,
);
}
"priceSchedules" => {
obj.price_schedules.get_or_insert(vec![]).extend(
PriceScheduleListDeserializer::deserialize("priceSchedules", stack)?,
);
}
"reservedInstancesId" => {
obj.reserved_instances_id = Some(StringDeserializer::deserialize(
"reservedInstancesId",
stack,
)?);
}
"reservedInstancesListingId" => {
obj.reserved_instances_listing_id = Some(StringDeserializer::deserialize(
"reservedInstancesListingId",
stack,
)?);
}
"status" => {
obj.status = Some(ListingStatusDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"updateDate" => {
obj.update_date =
Some(DateTimeDeserializer::deserialize("updateDate", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ReservedInstancesListingListDeserializer;
impl ReservedInstancesListingListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstancesListing>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservedInstancesListingDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstancesModification {
pub client_token: Option<String>,
pub create_date: Option<String>,
pub effective_date: Option<String>,
pub modification_results: Option<Vec<ReservedInstancesModificationResult>>,
pub reserved_instances_ids: Option<Vec<ReservedInstancesId>>,
pub reserved_instances_modification_id: Option<String>,
pub status: Option<String>,
pub status_message: Option<String>,
pub update_date: Option<String>,
}
struct ReservedInstancesModificationDeserializer;
impl ReservedInstancesModificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstancesModification, XmlParseError> {
deserialize_elements::<_, ReservedInstancesModification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"createDate" => {
obj.create_date =
Some(DateTimeDeserializer::deserialize("createDate", stack)?);
}
"effectiveDate" => {
obj.effective_date =
Some(DateTimeDeserializer::deserialize("effectiveDate", stack)?);
}
"modificationResultSet" => {
obj.modification_results.get_or_insert(vec![]).extend(
ReservedInstancesModificationResultListDeserializer::deserialize(
"modificationResultSet",
stack,
)?,
);
}
"reservedInstancesSet" => {
obj.reserved_instances_ids.get_or_insert(vec![]).extend(
ReservedIntancesIdsDeserializer::deserialize(
"reservedInstancesSet",
stack,
)?,
);
}
"reservedInstancesModificationId" => {
obj.reserved_instances_modification_id =
Some(StringDeserializer::deserialize(
"reservedInstancesModificationId",
stack,
)?);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"updateDate" => {
obj.update_date =
Some(DateTimeDeserializer::deserialize("updateDate", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ReservedInstancesModificationIdStringListSerializer;
impl ReservedInstancesModificationIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ReservedInstancesModificationListDeserializer;
impl ReservedInstancesModificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstancesModification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservedInstancesModificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstancesModificationResult {
pub reserved_instances_id: Option<String>,
pub target_configuration: Option<ReservedInstancesConfiguration>,
}
struct ReservedInstancesModificationResultDeserializer;
impl ReservedInstancesModificationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstancesModificationResult, XmlParseError> {
deserialize_elements::<_, ReservedInstancesModificationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"reservedInstancesId" => {
obj.reserved_instances_id = Some(StringDeserializer::deserialize(
"reservedInstancesId",
stack,
)?);
}
"targetConfiguration" => {
obj.target_configuration =
Some(ReservedInstancesConfigurationDeserializer::deserialize(
"targetConfiguration",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ReservedInstancesModificationResultListDeserializer;
impl ReservedInstancesModificationResultListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstancesModificationResult>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
ReservedInstancesModificationResultDeserializer::deserialize("item", stack)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedInstancesOffering {
pub availability_zone: Option<String>,
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub fixed_price: Option<f32>,
pub instance_tenancy: Option<String>,
pub instance_type: Option<String>,
pub marketplace: Option<bool>,
pub offering_class: Option<String>,
pub offering_type: Option<String>,
pub pricing_details: Option<Vec<PricingDetail>>,
pub product_description: Option<String>,
pub recurring_charges: Option<Vec<RecurringCharge>>,
pub reserved_instances_offering_id: Option<String>,
pub scope: Option<String>,
pub usage_price: Option<f32>,
}
struct ReservedInstancesOfferingDeserializer;
impl ReservedInstancesOfferingDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedInstancesOffering, XmlParseError> {
deserialize_elements::<_, ReservedInstancesOffering, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"currencyCode" => {
obj.currency_code = Some(CurrencyCodeValuesDeserializer::deserialize(
"currencyCode",
stack,
)?);
}
"duration" => {
obj.duration = Some(LongDeserializer::deserialize("duration", stack)?);
}
"fixedPrice" => {
obj.fixed_price =
Some(FloatDeserializer::deserialize("fixedPrice", stack)?);
}
"instanceTenancy" => {
obj.instance_tenancy =
Some(TenancyDeserializer::deserialize("instanceTenancy", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"marketplace" => {
obj.marketplace =
Some(BooleanDeserializer::deserialize("marketplace", stack)?);
}
"offeringClass" => {
obj.offering_class = Some(OfferingClassTypeDeserializer::deserialize(
"offeringClass",
stack,
)?);
}
"offeringType" => {
obj.offering_type = Some(OfferingTypeValuesDeserializer::deserialize(
"offeringType",
stack,
)?);
}
"pricingDetailsSet" => {
obj.pricing_details.get_or_insert(vec![]).extend(
PricingDetailsListDeserializer::deserialize(
"pricingDetailsSet",
stack,
)?,
);
}
"productDescription" => {
obj.product_description =
Some(RIProductDescriptionDeserializer::deserialize(
"productDescription",
stack,
)?);
}
"recurringCharges" => {
obj.recurring_charges.get_or_insert(vec![]).extend(
RecurringChargesListDeserializer::deserialize(
"recurringCharges",
stack,
)?,
);
}
"reservedInstancesOfferingId" => {
obj.reserved_instances_offering_id = Some(StringDeserializer::deserialize(
"reservedInstancesOfferingId",
stack,
)?);
}
"scope" => {
obj.scope = Some(ScopeDeserializer::deserialize("scope", stack)?);
}
"usagePrice" => {
obj.usage_price =
Some(FloatDeserializer::deserialize("usagePrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ReservedInstancesOfferingIdStringListSerializer;
impl ReservedInstancesOfferingIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ReservedInstancesOfferingListDeserializer;
impl ReservedInstancesOfferingListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstancesOffering>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservedInstancesOfferingDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ReservedIntancesIdsDeserializer;
impl ReservedIntancesIdsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedInstancesId>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ReservedInstancesIdDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetEbsDefaultKmsKeyIdRequest {
pub dry_run: Option<bool>,
}
struct ResetEbsDefaultKmsKeyIdRequestSerializer;
impl ResetEbsDefaultKmsKeyIdRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetEbsDefaultKmsKeyIdRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetEbsDefaultKmsKeyIdResult {
pub kms_key_id: Option<String>,
}
struct ResetEbsDefaultKmsKeyIdResultDeserializer;
impl ResetEbsDefaultKmsKeyIdResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResetEbsDefaultKmsKeyIdResult, XmlParseError> {
deserialize_elements::<_, ResetEbsDefaultKmsKeyIdResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetFpgaImageAttributeRequest {
pub attribute: Option<String>,
pub dry_run: Option<bool>,
pub fpga_image_id: String,
}
struct ResetFpgaImageAttributeRequestSerializer;
impl ResetFpgaImageAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetFpgaImageAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute {
params.put(&format!("{}{}", prefix, "Attribute"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "FpgaImageId"), &obj.fpga_image_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetFpgaImageAttributeResult {
pub return_: Option<bool>,
}
struct ResetFpgaImageAttributeResultDeserializer;
impl ResetFpgaImageAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResetFpgaImageAttributeResult, XmlParseError> {
deserialize_elements::<_, ResetFpgaImageAttributeResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetImageAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub image_id: String,
}
struct ResetImageAttributeRequestSerializer;
impl ResetImageAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetImageAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "ImageId"), &obj.image_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetInstanceAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub instance_id: String,
}
struct ResetInstanceAttributeRequestSerializer;
impl ResetInstanceAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetInstanceAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetNetworkInterfaceAttributeRequest {
pub dry_run: Option<bool>,
pub network_interface_id: String,
pub source_dest_check: Option<String>,
}
struct ResetNetworkInterfaceAttributeRequestSerializer;
impl ResetNetworkInterfaceAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetNetworkInterfaceAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
if let Some(ref field_value) = obj.source_dest_check {
params.put(&format!("{}{}", prefix, "SourceDestCheck"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetSnapshotAttributeRequest {
pub attribute: String,
pub dry_run: Option<bool>,
pub snapshot_id: String,
}
struct ResetSnapshotAttributeRequestSerializer;
impl ResetSnapshotAttributeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetSnapshotAttributeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "SnapshotId"), &obj.snapshot_id);
}
}
struct ResourceIdListSerializer;
impl ResourceIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ResourceListSerializer;
impl ResourceListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ResourceTypeDeserializer;
impl ResourceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResponseError {
pub code: Option<String>,
pub message: Option<String>,
}
struct ResponseErrorDeserializer;
impl ResponseErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResponseError, XmlParseError> {
deserialize_elements::<_, ResponseError, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(LaunchTemplateErrorCodeDeserializer::deserialize(
"code", stack,
)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ResponseHostIdListDeserializer;
impl ResponseHostIdListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ResponseHostIdSetDeserializer;
impl ResponseHostIdSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResponseLaunchTemplateData {
pub block_device_mappings: Option<Vec<LaunchTemplateBlockDeviceMapping>>,
pub capacity_reservation_specification:
Option<LaunchTemplateCapacityReservationSpecificationResponse>,
pub cpu_options: Option<LaunchTemplateCpuOptions>,
pub credit_specification: Option<CreditSpecification>,
pub disable_api_termination: Option<bool>,
pub ebs_optimized: Option<bool>,
pub elastic_gpu_specifications: Option<Vec<ElasticGpuSpecificationResponse>>,
pub elastic_inference_accelerators:
Option<Vec<LaunchTemplateElasticInferenceAcceleratorResponse>>,
pub hibernation_options: Option<LaunchTemplateHibernationOptions>,
pub iam_instance_profile: Option<LaunchTemplateIamInstanceProfileSpecification>,
pub image_id: Option<String>,
pub instance_initiated_shutdown_behavior: Option<String>,
pub instance_market_options: Option<LaunchTemplateInstanceMarketOptions>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub license_specifications: Option<Vec<LaunchTemplateLicenseConfiguration>>,
pub monitoring: Option<LaunchTemplatesMonitoring>,
pub network_interfaces: Option<Vec<LaunchTemplateInstanceNetworkInterfaceSpecification>>,
pub placement: Option<LaunchTemplatePlacement>,
pub ram_disk_id: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub security_groups: Option<Vec<String>>,
pub tag_specifications: Option<Vec<LaunchTemplateTagSpecification>>,
pub user_data: Option<String>,
}
struct ResponseLaunchTemplateDataDeserializer;
impl ResponseLaunchTemplateDataDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResponseLaunchTemplateData, XmlParseError> {
deserialize_elements::<_, ResponseLaunchTemplateData, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"blockDeviceMappingSet" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
LaunchTemplateBlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMappingSet",
stack,
)?,
);
}
"capacityReservationSpecification" => {
obj.capacity_reservation_specification = Some(LaunchTemplateCapacityReservationSpecificationResponseDeserializer::deserialize("capacityReservationSpecification", stack)?);
}
"cpuOptions" => {
obj.cpu_options = Some(LaunchTemplateCpuOptionsDeserializer::deserialize(
"cpuOptions",
stack,
)?);
}
"creditSpecification" => {
obj.credit_specification =
Some(CreditSpecificationDeserializer::deserialize(
"creditSpecification",
stack,
)?);
}
"disableApiTermination" => {
obj.disable_api_termination = Some(BooleanDeserializer::deserialize(
"disableApiTermination",
stack,
)?);
}
"ebsOptimized" => {
obj.ebs_optimized =
Some(BooleanDeserializer::deserialize("ebsOptimized", stack)?);
}
"elasticGpuSpecificationSet" => {
obj.elastic_gpu_specifications.get_or_insert(vec![]).extend(
ElasticGpuSpecificationResponseListDeserializer::deserialize(
"elasticGpuSpecificationSet",
stack,
)?,
);
}
"elasticInferenceAcceleratorSet" => {
obj.elastic_inference_accelerators
.get_or_insert(vec![])
.extend(LaunchTemplateElasticInferenceAcceleratorResponseListDeserializer::deserialize("elasticInferenceAcceleratorSet", stack)?);
}
"hibernationOptions" => {
obj.hibernation_options =
Some(LaunchTemplateHibernationOptionsDeserializer::deserialize(
"hibernationOptions",
stack,
)?);
}
"iamInstanceProfile" => {
obj.iam_instance_profile = Some(
LaunchTemplateIamInstanceProfileSpecificationDeserializer::deserialize(
"iamInstanceProfile",
stack,
)?,
);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"instanceInitiatedShutdownBehavior" => {
obj.instance_initiated_shutdown_behavior =
Some(ShutdownBehaviorDeserializer::deserialize(
"instanceInitiatedShutdownBehavior",
stack,
)?);
}
"instanceMarketOptions" => {
obj.instance_market_options = Some(
LaunchTemplateInstanceMarketOptionsDeserializer::deserialize(
"instanceMarketOptions",
stack,
)?,
);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"kernelId" => {
obj.kernel_id = Some(StringDeserializer::deserialize("kernelId", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
"licenseSet" => {
obj.license_specifications.get_or_insert(vec![]).extend(
LaunchTemplateLicenseListDeserializer::deserialize(
"licenseSet",
stack,
)?,
);
}
"monitoring" => {
obj.monitoring = Some(LaunchTemplatesMonitoringDeserializer::deserialize(
"monitoring",
stack,
)?);
}
"networkInterfaceSet" => {
obj.network_interfaces
.get_or_insert(vec![])
.extend(LaunchTemplateInstanceNetworkInterfaceSpecificationListDeserializer::deserialize("networkInterfaceSet", stack)?);
}
"placement" => {
obj.placement = Some(LaunchTemplatePlacementDeserializer::deserialize(
"placement",
stack,
)?);
}
"ramDiskId" => {
obj.ram_disk_id =
Some(StringDeserializer::deserialize("ramDiskId", stack)?);
}
"securityGroupIdSet" => {
obj.security_group_ids.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("securityGroupIdSet", stack)?,
);
}
"securityGroupSet" => {
obj.security_groups.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("securityGroupSet", stack)?,
);
}
"tagSpecificationSet" => {
obj.tag_specifications.get_or_insert(vec![]).extend(
LaunchTemplateTagSpecificationListDeserializer::deserialize(
"tagSpecificationSet",
stack,
)?,
);
}
"userData" => {
obj.user_data = Some(StringDeserializer::deserialize("userData", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct RestorableByStringListSerializer;
impl RestorableByStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RestoreAddressToClassicRequest {
pub dry_run: Option<bool>,
pub public_ip: String,
}
struct RestoreAddressToClassicRequestSerializer;
impl RestoreAddressToClassicRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RestoreAddressToClassicRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
params.put(&format!("{}{}", prefix, "PublicIp"), &obj.public_ip);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RestoreAddressToClassicResult {
pub public_ip: Option<String>,
pub status: Option<String>,
}
struct RestoreAddressToClassicResultDeserializer;
impl RestoreAddressToClassicResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreAddressToClassicResult, XmlParseError> {
deserialize_elements::<_, RestoreAddressToClassicResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"publicIp" => {
obj.public_ip = Some(StringDeserializer::deserialize("publicIp", stack)?);
}
"status" => {
obj.status = Some(StatusDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RevokeClientVpnIngressRequest {
pub access_group_id: Option<String>,
pub client_vpn_endpoint_id: String,
pub dry_run: Option<bool>,
pub revoke_all_groups: Option<bool>,
pub target_network_cidr: String,
}
struct RevokeClientVpnIngressRequestSerializer;
impl RevokeClientVpnIngressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RevokeClientVpnIngressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.access_group_id {
params.put(&format!("{}{}", prefix, "AccessGroupId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.revoke_all_groups {
params.put(&format!("{}{}", prefix, "RevokeAllGroups"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TargetNetworkCidr"),
&obj.target_network_cidr,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RevokeClientVpnIngressResult {
pub status: Option<ClientVpnAuthorizationRuleStatus>,
}
struct RevokeClientVpnIngressResultDeserializer;
impl RevokeClientVpnIngressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevokeClientVpnIngressResult, XmlParseError> {
deserialize_elements::<_, RevokeClientVpnIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"status" => {
obj.status =
Some(ClientVpnAuthorizationRuleStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RevokeSecurityGroupEgressRequest {
pub cidr_ip: Option<String>,
pub dry_run: Option<bool>,
pub from_port: Option<i64>,
pub group_id: String,
pub ip_permissions: Option<Vec<IpPermission>>,
pub ip_protocol: Option<String>,
pub source_security_group_name: Option<String>,
pub source_security_group_owner_id: Option<String>,
pub to_port: Option<i64>,
}
struct RevokeSecurityGroupEgressRequestSerializer;
impl RevokeSecurityGroupEgressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RevokeSecurityGroupEgressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_ip {
params.put(&format!("{}{}", prefix, "CidrIp"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.from_port {
params.put(&format!("{}{}", prefix, "FromPort"), &field_value);
}
params.put(&format!("{}{}", prefix, "GroupId"), &obj.group_id);
if let Some(ref field_value) = obj.ip_permissions {
IpPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpPermissions"),
field_value,
);
}
if let Some(ref field_value) = obj.ip_protocol {
params.put(&format!("{}{}", prefix, "IpProtocol"), &field_value);
}
if let Some(ref field_value) = obj.source_security_group_name {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.source_security_group_owner_id {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupOwnerId"),
&field_value,
);
}
if let Some(ref field_value) = obj.to_port {
params.put(&format!("{}{}", prefix, "ToPort"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RevokeSecurityGroupIngressRequest {
pub cidr_ip: Option<String>,
pub dry_run: Option<bool>,
pub from_port: Option<i64>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub ip_permissions: Option<Vec<IpPermission>>,
pub ip_protocol: Option<String>,
pub source_security_group_name: Option<String>,
pub source_security_group_owner_id: Option<String>,
pub to_port: Option<i64>,
}
struct RevokeSecurityGroupIngressRequestSerializer;
impl RevokeSecurityGroupIngressRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RevokeSecurityGroupIngressRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidr_ip {
params.put(&format!("{}{}", prefix, "CidrIp"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.from_port {
params.put(&format!("{}{}", prefix, "FromPort"), &field_value);
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.ip_permissions {
IpPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpPermissions"),
field_value,
);
}
if let Some(ref field_value) = obj.ip_protocol {
params.put(&format!("{}{}", prefix, "IpProtocol"), &field_value);
}
if let Some(ref field_value) = obj.source_security_group_name {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.source_security_group_owner_id {
params.put(
&format!("{}{}", prefix, "SourceSecurityGroupOwnerId"),
&field_value,
);
}
if let Some(ref field_value) = obj.to_port {
params.put(&format!("{}{}", prefix, "ToPort"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Route {
pub destination_cidr_block: Option<String>,
pub destination_ipv_6_cidr_block: Option<String>,
pub destination_prefix_list_id: Option<String>,
pub egress_only_internet_gateway_id: Option<String>,
pub gateway_id: Option<String>,
pub instance_id: Option<String>,
pub instance_owner_id: Option<String>,
pub nat_gateway_id: Option<String>,
pub network_interface_id: Option<String>,
pub origin: Option<String>,
pub state: Option<String>,
pub transit_gateway_id: Option<String>,
pub vpc_peering_connection_id: Option<String>,
}
struct RouteDeserializer;
impl RouteDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Route, XmlParseError> {
deserialize_elements::<_, Route, _>(tag_name, stack, |name, stack, obj| {
match name {
"destinationCidrBlock" => {
obj.destination_cidr_block = Some(StringDeserializer::deserialize(
"destinationCidrBlock",
stack,
)?);
}
"destinationIpv6CidrBlock" => {
obj.destination_ipv_6_cidr_block = Some(StringDeserializer::deserialize(
"destinationIpv6CidrBlock",
stack,
)?);
}
"destinationPrefixListId" => {
obj.destination_prefix_list_id = Some(StringDeserializer::deserialize(
"destinationPrefixListId",
stack,
)?);
}
"egressOnlyInternetGatewayId" => {
obj.egress_only_internet_gateway_id = Some(StringDeserializer::deserialize(
"egressOnlyInternetGatewayId",
stack,
)?);
}
"gatewayId" => {
obj.gateway_id = Some(StringDeserializer::deserialize("gatewayId", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceOwnerId" => {
obj.instance_owner_id =
Some(StringDeserializer::deserialize("instanceOwnerId", stack)?);
}
"natGatewayId" => {
obj.nat_gateway_id =
Some(StringDeserializer::deserialize("natGatewayId", stack)?);
}
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"origin" => {
obj.origin = Some(RouteOriginDeserializer::deserialize("origin", stack)?);
}
"state" => {
obj.state = Some(RouteStateDeserializer::deserialize("state", stack)?);
}
"transitGatewayId" => {
obj.transit_gateway_id =
Some(StringDeserializer::deserialize("transitGatewayId", stack)?);
}
"vpcPeeringConnectionId" => {
obj.vpc_peering_connection_id = Some(StringDeserializer::deserialize(
"vpcPeeringConnectionId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RouteListDeserializer;
impl RouteListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Route>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(RouteDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RouteOriginDeserializer;
impl RouteOriginDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct RouteStateDeserializer;
impl RouteStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RouteTable {
pub associations: Option<Vec<RouteTableAssociation>>,
pub owner_id: Option<String>,
pub propagating_vgws: Option<Vec<PropagatingVgw>>,
pub route_table_id: Option<String>,
pub routes: Option<Vec<Route>>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct RouteTableDeserializer;
impl RouteTableDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RouteTable, XmlParseError> {
deserialize_elements::<_, RouteTable, _>(tag_name, stack, |name, stack, obj| {
match name {
"associationSet" => {
obj.associations.get_or_insert(vec![]).extend(
RouteTableAssociationListDeserializer::deserialize(
"associationSet",
stack,
)?,
);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"propagatingVgwSet" => {
obj.propagating_vgws.get_or_insert(vec![]).extend(
PropagatingVgwListDeserializer::deserialize("propagatingVgwSet", stack)?,
);
}
"routeTableId" => {
obj.route_table_id =
Some(StringDeserializer::deserialize("routeTableId", stack)?);
}
"routeSet" => {
obj.routes
.get_or_insert(vec![])
.extend(RouteListDeserializer::deserialize("routeSet", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RouteTableAssociation {
pub main: Option<bool>,
pub route_table_association_id: Option<String>,
pub route_table_id: Option<String>,
pub subnet_id: Option<String>,
}
struct RouteTableAssociationDeserializer;
impl RouteTableAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RouteTableAssociation, XmlParseError> {
deserialize_elements::<_, RouteTableAssociation, _>(tag_name, stack, |name, stack, obj| {
match name {
"main" => {
obj.main = Some(BooleanDeserializer::deserialize("main", stack)?);
}
"routeTableAssociationId" => {
obj.route_table_association_id = Some(StringDeserializer::deserialize(
"routeTableAssociationId",
stack,
)?);
}
"routeTableId" => {
obj.route_table_id =
Some(StringDeserializer::deserialize("routeTableId", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RouteTableAssociationListDeserializer;
impl RouteTableAssociationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RouteTableAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(RouteTableAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RouteTableListDeserializer;
impl RouteTableListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RouteTable>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(RouteTableDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RuleActionDeserializer;
impl RuleActionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RunInstancesMonitoringEnabled {
pub enabled: bool,
}
struct RunInstancesMonitoringEnabledDeserializer;
impl RunInstancesMonitoringEnabledDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RunInstancesMonitoringEnabled, XmlParseError> {
deserialize_elements::<_, RunInstancesMonitoringEnabled, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"enabled" => {
obj.enabled = BooleanDeserializer::deserialize("enabled", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct RunInstancesMonitoringEnabledSerializer;
impl RunInstancesMonitoringEnabledSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RunInstancesMonitoringEnabled) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Enabled"), &obj.enabled);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RunInstancesRequest {
pub additional_info: Option<String>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub capacity_reservation_specification: Option<CapacityReservationSpecification>,
pub client_token: Option<String>,
pub cpu_options: Option<CpuOptionsRequest>,
pub credit_specification: Option<CreditSpecificationRequest>,
pub disable_api_termination: Option<bool>,
pub dry_run: Option<bool>,
pub ebs_optimized: Option<bool>,
pub elastic_gpu_specification: Option<Vec<ElasticGpuSpecification>>,
pub elastic_inference_accelerators: Option<Vec<ElasticInferenceAccelerator>>,
pub hibernation_options: Option<HibernationOptionsRequest>,
pub iam_instance_profile: Option<IamInstanceProfileSpecification>,
pub image_id: Option<String>,
pub instance_initiated_shutdown_behavior: Option<String>,
pub instance_market_options: Option<InstanceMarketOptionsRequest>,
pub instance_type: Option<String>,
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<InstanceIpv6Address>>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub launch_template: Option<LaunchTemplateSpecification>,
pub license_specifications: Option<Vec<LicenseConfigurationRequest>>,
pub max_count: i64,
pub min_count: i64,
pub monitoring: Option<RunInstancesMonitoringEnabled>,
pub network_interfaces: Option<Vec<InstanceNetworkInterfaceSpecification>>,
pub placement: Option<Placement>,
pub private_ip_address: Option<String>,
pub ramdisk_id: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub security_groups: Option<Vec<String>>,
pub subnet_id: Option<String>,
pub tag_specifications: Option<Vec<TagSpecification>>,
pub user_data: Option<String>,
}
struct RunInstancesRequestSerializer;
impl RunInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RunInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.additional_info {
params.put(&format!("{}{}", prefix, "AdditionalInfo"), &field_value);
}
if let Some(ref field_value) = obj.block_device_mappings {
BlockDeviceMappingRequestListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.capacity_reservation_specification {
CapacityReservationSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "CapacityReservationSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.cpu_options {
CpuOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "CpuOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.credit_specification {
CreditSpecificationRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "CreditSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.disable_api_termination {
params.put(
&format!("{}{}", prefix, "DisableApiTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(&format!("{}{}", prefix, "EbsOptimized"), &field_value);
}
if let Some(ref field_value) = obj.elastic_gpu_specification {
ElasticGpuSpecificationsSerializer::serialize(
params,
&format!("{}{}", prefix, "ElasticGpuSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.elastic_inference_accelerators {
ElasticInferenceAcceleratorsSerializer::serialize(
params,
&format!("{}{}", prefix, "ElasticInferenceAccelerator"),
field_value,
);
}
if let Some(ref field_value) = obj.hibernation_options {
HibernationOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "HibernationOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.iam_instance_profile {
IamInstanceProfileSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
field_value,
);
}
if let Some(ref field_value) = obj.image_id {
params.put(&format!("{}{}", prefix, "ImageId"), &field_value);
}
if let Some(ref field_value) = obj.instance_initiated_shutdown_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInitiatedShutdownBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_market_options {
InstanceMarketOptionsRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceMarketOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_address_count {
params.put(&format!("{}{}", prefix, "Ipv6AddressCount"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_addresses {
InstanceIpv6AddressListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Address"),
field_value,
);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
if let Some(ref field_value) = obj.key_name {
params.put(&format!("{}{}", prefix, "KeyName"), &field_value);
}
if let Some(ref field_value) = obj.launch_template {
LaunchTemplateSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplate"),
field_value,
);
}
if let Some(ref field_value) = obj.license_specifications {
LicenseSpecificationListRequestSerializer::serialize(
params,
&format!("{}{}", prefix, "LicenseSpecification"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "MaxCount"), &obj.max_count);
params.put(&format!("{}{}", prefix, "MinCount"), &obj.min_count);
if let Some(ref field_value) = obj.monitoring {
RunInstancesMonitoringEnabledSerializer::serialize(
params,
&format!("{}{}", prefix, "Monitoring"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interfaces {
InstanceNetworkInterfaceSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterface"),
field_value,
);
}
if let Some(ref field_value) = obj.placement {
PlacementSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.ramdisk_id {
params.put(&format!("{}{}", prefix, "RamdiskId"), &field_value);
}
if let Some(ref field_value) = obj.security_group_ids {
SecurityGroupIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.security_groups {
SecurityGroupStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.tag_specifications {
TagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.user_data {
params.put(&format!("{}{}", prefix, "UserData"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RunScheduledInstancesRequest {
pub client_token: Option<String>,
pub dry_run: Option<bool>,
pub instance_count: Option<i64>,
pub launch_specification: ScheduledInstancesLaunchSpecification,
pub scheduled_instance_id: String,
}
struct RunScheduledInstancesRequestSerializer;
impl RunScheduledInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RunScheduledInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.instance_count {
params.put(&format!("{}{}", prefix, "InstanceCount"), &field_value);
}
ScheduledInstancesLaunchSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchSpecification"),
&obj.launch_specification,
);
params.put(
&format!("{}{}", prefix, "ScheduledInstanceId"),
&obj.scheduled_instance_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RunScheduledInstancesResult {
pub instance_id_set: Option<Vec<String>>,
}
struct RunScheduledInstancesResultDeserializer;
impl RunScheduledInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RunScheduledInstancesResult, XmlParseError> {
deserialize_elements::<_, RunScheduledInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instanceIdSet" => {
obj.instance_id_set.get_or_insert(vec![]).extend(
InstanceIdSetDeserializer::deserialize("instanceIdSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct S3Storage {
pub aws_access_key_id: Option<String>,
pub bucket: Option<String>,
pub prefix: Option<String>,
pub upload_policy: Option<bytes::Bytes>,
pub upload_policy_signature: Option<String>,
}
struct S3StorageDeserializer;
impl S3StorageDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<S3Storage, XmlParseError> {
deserialize_elements::<_, S3Storage, _>(tag_name, stack, |name, stack, obj| {
match name {
"AWSAccessKeyId" => {
obj.aws_access_key_id =
Some(StringDeserializer::deserialize("AWSAccessKeyId", stack)?);
}
"bucket" => {
obj.bucket = Some(StringDeserializer::deserialize("bucket", stack)?);
}
"prefix" => {
obj.prefix = Some(StringDeserializer::deserialize("prefix", stack)?);
}
"uploadPolicy" => {
obj.upload_policy = Some(BlobDeserializer::deserialize("uploadPolicy", stack)?);
}
"uploadPolicySignature" => {
obj.upload_policy_signature = Some(StringDeserializer::deserialize(
"uploadPolicySignature",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct S3StorageSerializer;
impl S3StorageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &S3Storage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.aws_access_key_id {
params.put(&format!("{}{}", prefix, "AWSAccessKeyId"), &field_value);
}
if let Some(ref field_value) = obj.bucket {
params.put(&format!("{}{}", prefix, "Bucket"), &field_value);
}
if let Some(ref field_value) = obj.prefix {
params.put(&format!("{}{}", prefix, "Prefix"), &field_value);
}
if let Some(ref field_value) = obj.upload_policy {
params.put(
&format!("{}{}", prefix, "UploadPolicy"),
::std::str::from_utf8(&field_value).unwrap(),
);
}
if let Some(ref field_value) = obj.upload_policy_signature {
params.put(
&format!("{}{}", prefix, "UploadPolicySignature"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstance {
pub availability_zone: Option<String>,
pub create_date: Option<String>,
pub hourly_price: Option<String>,
pub instance_count: Option<i64>,
pub instance_type: Option<String>,
pub network_platform: Option<String>,
pub next_slot_start_time: Option<String>,
pub platform: Option<String>,
pub previous_slot_end_time: Option<String>,
pub recurrence: Option<ScheduledInstanceRecurrence>,
pub scheduled_instance_id: Option<String>,
pub slot_duration_in_hours: Option<i64>,
pub term_end_date: Option<String>,
pub term_start_date: Option<String>,
pub total_scheduled_instance_hours: Option<i64>,
}
struct ScheduledInstanceDeserializer;
impl ScheduledInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledInstance, XmlParseError> {
deserialize_elements::<_, ScheduledInstance, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"createDate" => {
obj.create_date = Some(DateTimeDeserializer::deserialize("createDate", stack)?);
}
"hourlyPrice" => {
obj.hourly_price = Some(StringDeserializer::deserialize("hourlyPrice", stack)?);
}
"instanceCount" => {
obj.instance_count =
Some(IntegerDeserializer::deserialize("instanceCount", stack)?);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
"networkPlatform" => {
obj.network_platform =
Some(StringDeserializer::deserialize("networkPlatform", stack)?);
}
"nextSlotStartTime" => {
obj.next_slot_start_time = Some(DateTimeDeserializer::deserialize(
"nextSlotStartTime",
stack,
)?);
}
"platform" => {
obj.platform = Some(StringDeserializer::deserialize("platform", stack)?);
}
"previousSlotEndTime" => {
obj.previous_slot_end_time = Some(DateTimeDeserializer::deserialize(
"previousSlotEndTime",
stack,
)?);
}
"recurrence" => {
obj.recurrence = Some(ScheduledInstanceRecurrenceDeserializer::deserialize(
"recurrence",
stack,
)?);
}
"scheduledInstanceId" => {
obj.scheduled_instance_id = Some(StringDeserializer::deserialize(
"scheduledInstanceId",
stack,
)?);
}
"slotDurationInHours" => {
obj.slot_duration_in_hours = Some(IntegerDeserializer::deserialize(
"slotDurationInHours",
stack,
)?);
}
"termEndDate" => {
obj.term_end_date =
Some(DateTimeDeserializer::deserialize("termEndDate", stack)?);
}
"termStartDate" => {
obj.term_start_date =
Some(DateTimeDeserializer::deserialize("termStartDate", stack)?);
}
"totalScheduledInstanceHours" => {
obj.total_scheduled_instance_hours = Some(IntegerDeserializer::deserialize(
"totalScheduledInstanceHours",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstanceAvailability {
pub availability_zone: Option<String>,
pub available_instance_count: Option<i64>,
pub first_slot_start_time: Option<String>,
pub hourly_price: Option<String>,
pub instance_type: Option<String>,
pub max_term_duration_in_days: Option<i64>,
pub min_term_duration_in_days: Option<i64>,
pub network_platform: Option<String>,
pub platform: Option<String>,
pub purchase_token: Option<String>,
pub recurrence: Option<ScheduledInstanceRecurrence>,
pub slot_duration_in_hours: Option<i64>,
pub total_scheduled_instance_hours: Option<i64>,
}
struct ScheduledInstanceAvailabilityDeserializer;
impl ScheduledInstanceAvailabilityDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledInstanceAvailability, XmlParseError> {
deserialize_elements::<_, ScheduledInstanceAvailability, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"availableInstanceCount" => {
obj.available_instance_count = Some(IntegerDeserializer::deserialize(
"availableInstanceCount",
stack,
)?);
}
"firstSlotStartTime" => {
obj.first_slot_start_time = Some(DateTimeDeserializer::deserialize(
"firstSlotStartTime",
stack,
)?);
}
"hourlyPrice" => {
obj.hourly_price =
Some(StringDeserializer::deserialize("hourlyPrice", stack)?);
}
"instanceType" => {
obj.instance_type =
Some(StringDeserializer::deserialize("instanceType", stack)?);
}
"maxTermDurationInDays" => {
obj.max_term_duration_in_days = Some(IntegerDeserializer::deserialize(
"maxTermDurationInDays",
stack,
)?);
}
"minTermDurationInDays" => {
obj.min_term_duration_in_days = Some(IntegerDeserializer::deserialize(
"minTermDurationInDays",
stack,
)?);
}
"networkPlatform" => {
obj.network_platform =
Some(StringDeserializer::deserialize("networkPlatform", stack)?);
}
"platform" => {
obj.platform = Some(StringDeserializer::deserialize("platform", stack)?);
}
"purchaseToken" => {
obj.purchase_token =
Some(StringDeserializer::deserialize("purchaseToken", stack)?);
}
"recurrence" => {
obj.recurrence =
Some(ScheduledInstanceRecurrenceDeserializer::deserialize(
"recurrence",
stack,
)?);
}
"slotDurationInHours" => {
obj.slot_duration_in_hours = Some(IntegerDeserializer::deserialize(
"slotDurationInHours",
stack,
)?);
}
"totalScheduledInstanceHours" => {
obj.total_scheduled_instance_hours = Some(
IntegerDeserializer::deserialize("totalScheduledInstanceHours", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ScheduledInstanceAvailabilitySetDeserializer;
impl ScheduledInstanceAvailabilitySetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ScheduledInstanceAvailability>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ScheduledInstanceAvailabilityDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ScheduledInstanceIdRequestSetSerializer;
impl ScheduledInstanceIdRequestSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstanceRecurrence {
pub frequency: Option<String>,
pub interval: Option<i64>,
pub occurrence_day_set: Option<Vec<i64>>,
pub occurrence_relative_to_end: Option<bool>,
pub occurrence_unit: Option<String>,
}
struct ScheduledInstanceRecurrenceDeserializer;
impl ScheduledInstanceRecurrenceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledInstanceRecurrence, XmlParseError> {
deserialize_elements::<_, ScheduledInstanceRecurrence, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"frequency" => {
obj.frequency = Some(StringDeserializer::deserialize("frequency", stack)?);
}
"interval" => {
obj.interval = Some(IntegerDeserializer::deserialize("interval", stack)?);
}
"occurrenceDaySet" => {
obj.occurrence_day_set.get_or_insert(vec![]).extend(
OccurrenceDaySetDeserializer::deserialize("occurrenceDaySet", stack)?,
);
}
"occurrenceRelativeToEnd" => {
obj.occurrence_relative_to_end = Some(BooleanDeserializer::deserialize(
"occurrenceRelativeToEnd",
stack,
)?);
}
"occurrenceUnit" => {
obj.occurrence_unit =
Some(StringDeserializer::deserialize("occurrenceUnit", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstanceRecurrenceRequest {
pub frequency: Option<String>,
pub interval: Option<i64>,
pub occurrence_days: Option<Vec<i64>>,
pub occurrence_relative_to_end: Option<bool>,
pub occurrence_unit: Option<String>,
}
struct ScheduledInstanceRecurrenceRequestSerializer;
impl ScheduledInstanceRecurrenceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstanceRecurrenceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.frequency {
params.put(&format!("{}{}", prefix, "Frequency"), &field_value);
}
if let Some(ref field_value) = obj.interval {
params.put(&format!("{}{}", prefix, "Interval"), &field_value);
}
if let Some(ref field_value) = obj.occurrence_days {
OccurrenceDayRequestSetSerializer::serialize(
params,
&format!("{}{}", prefix, "OccurrenceDay"),
field_value,
);
}
if let Some(ref field_value) = obj.occurrence_relative_to_end {
params.put(
&format!("{}{}", prefix, "OccurrenceRelativeToEnd"),
&field_value,
);
}
if let Some(ref field_value) = obj.occurrence_unit {
params.put(&format!("{}{}", prefix, "OccurrenceUnit"), &field_value);
}
}
}
struct ScheduledInstanceSetDeserializer;
impl ScheduledInstanceSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ScheduledInstance>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ScheduledInstanceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesBlockDeviceMapping {
pub device_name: Option<String>,
pub ebs: Option<ScheduledInstancesEbs>,
pub no_device: Option<String>,
pub virtual_name: Option<String>,
}
struct ScheduledInstancesBlockDeviceMappingSerializer;
impl ScheduledInstancesBlockDeviceMappingSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesBlockDeviceMapping) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.device_name {
params.put(&format!("{}{}", prefix, "DeviceName"), &field_value);
}
if let Some(ref field_value) = obj.ebs {
ScheduledInstancesEbsSerializer::serialize(
params,
&format!("{}{}", prefix, "Ebs"),
field_value,
);
}
if let Some(ref field_value) = obj.no_device {
params.put(&format!("{}{}", prefix, "NoDevice"), &field_value);
}
if let Some(ref field_value) = obj.virtual_name {
params.put(&format!("{}{}", prefix, "VirtualName"), &field_value);
}
}
}
struct ScheduledInstancesBlockDeviceMappingSetSerializer;
impl ScheduledInstancesBlockDeviceMappingSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ScheduledInstancesBlockDeviceMapping>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ScheduledInstancesBlockDeviceMappingSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesEbs {
pub delete_on_termination: Option<bool>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub snapshot_id: Option<String>,
pub volume_size: Option<i64>,
pub volume_type: Option<String>,
}
struct ScheduledInstancesEbsSerializer;
impl ScheduledInstancesEbsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesEbs) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_id {
params.put(&format!("{}{}", prefix, "SnapshotId"), &field_value);
}
if let Some(ref field_value) = obj.volume_size {
params.put(&format!("{}{}", prefix, "VolumeSize"), &field_value);
}
if let Some(ref field_value) = obj.volume_type {
params.put(&format!("{}{}", prefix, "VolumeType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesIamInstanceProfile {
pub arn: Option<String>,
pub name: Option<String>,
}
struct ScheduledInstancesIamInstanceProfileSerializer;
impl ScheduledInstancesIamInstanceProfileSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesIamInstanceProfile) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.arn {
params.put(&format!("{}{}", prefix, "Arn"), &field_value);
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesIpv6Address {
pub ipv_6_address: Option<String>,
}
struct ScheduledInstancesIpv6AddressSerializer;
impl ScheduledInstancesIpv6AddressSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesIpv6Address) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.ipv_6_address {
params.put(&format!("{}{}", prefix, "Ipv6Address"), &field_value);
}
}
}
struct ScheduledInstancesIpv6AddressListSerializer;
impl ScheduledInstancesIpv6AddressListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ScheduledInstancesIpv6Address>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ScheduledInstancesIpv6AddressSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesLaunchSpecification {
pub block_device_mappings: Option<Vec<ScheduledInstancesBlockDeviceMapping>>,
pub ebs_optimized: Option<bool>,
pub iam_instance_profile: Option<ScheduledInstancesIamInstanceProfile>,
pub image_id: String,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub monitoring: Option<ScheduledInstancesMonitoring>,
pub network_interfaces: Option<Vec<ScheduledInstancesNetworkInterface>>,
pub placement: Option<ScheduledInstancesPlacement>,
pub ramdisk_id: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub subnet_id: Option<String>,
pub user_data: Option<String>,
}
struct ScheduledInstancesLaunchSpecificationSerializer;
impl ScheduledInstancesLaunchSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesLaunchSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.block_device_mappings {
ScheduledInstancesBlockDeviceMappingSetSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(&format!("{}{}", prefix, "EbsOptimized"), &field_value);
}
if let Some(ref field_value) = obj.iam_instance_profile {
ScheduledInstancesIamInstanceProfileSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "ImageId"), &obj.image_id);
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
if let Some(ref field_value) = obj.key_name {
params.put(&format!("{}{}", prefix, "KeyName"), &field_value);
}
if let Some(ref field_value) = obj.monitoring {
ScheduledInstancesMonitoringSerializer::serialize(
params,
&format!("{}{}", prefix, "Monitoring"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interfaces {
ScheduledInstancesNetworkInterfaceSetSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterface"),
field_value,
);
}
if let Some(ref field_value) = obj.placement {
ScheduledInstancesPlacementSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.ramdisk_id {
params.put(&format!("{}{}", prefix, "RamdiskId"), &field_value);
}
if let Some(ref field_value) = obj.security_group_ids {
ScheduledInstancesSecurityGroupIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.user_data {
params.put(&format!("{}{}", prefix, "UserData"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesMonitoring {
pub enabled: Option<bool>,
}
struct ScheduledInstancesMonitoringSerializer;
impl ScheduledInstancesMonitoringSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesMonitoring) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesNetworkInterface {
pub associate_public_ip_address: Option<bool>,
pub delete_on_termination: Option<bool>,
pub description: Option<String>,
pub device_index: Option<i64>,
pub groups: Option<Vec<String>>,
pub ipv_6_address_count: Option<i64>,
pub ipv_6_addresses: Option<Vec<ScheduledInstancesIpv6Address>>,
pub network_interface_id: Option<String>,
pub private_ip_address: Option<String>,
pub private_ip_address_configs: Option<Vec<ScheduledInstancesPrivateIpAddressConfig>>,
pub secondary_private_ip_address_count: Option<i64>,
pub subnet_id: Option<String>,
}
struct ScheduledInstancesNetworkInterfaceSerializer;
impl ScheduledInstancesNetworkInterfaceSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesNetworkInterface) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.associate_public_ip_address {
params.put(
&format!("{}{}", prefix, "AssociatePublicIpAddress"),
&field_value,
);
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.device_index {
params.put(&format!("{}{}", prefix, "DeviceIndex"), &field_value);
}
if let Some(ref field_value) = obj.groups {
ScheduledInstancesSecurityGroupIdSetSerializer::serialize(
params,
&format!("{}{}", prefix, "Group"),
field_value,
);
}
if let Some(ref field_value) = obj.ipv_6_address_count {
params.put(&format!("{}{}", prefix, "Ipv6AddressCount"), &field_value);
}
if let Some(ref field_value) = obj.ipv_6_addresses {
ScheduledInstancesIpv6AddressListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Address"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interface_id {
params.put(&format!("{}{}", prefix, "NetworkInterfaceId"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address_configs {
PrivateIpAddressConfigSetSerializer::serialize(
params,
&format!("{}{}", prefix, "PrivateIpAddressConfig"),
field_value,
);
}
if let Some(ref field_value) = obj.secondary_private_ip_address_count {
params.put(
&format!("{}{}", prefix, "SecondaryPrivateIpAddressCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
}
}
struct ScheduledInstancesNetworkInterfaceSetSerializer;
impl ScheduledInstancesNetworkInterfaceSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ScheduledInstancesNetworkInterface>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
ScheduledInstancesNetworkInterfaceSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesPlacement {
pub availability_zone: Option<String>,
pub group_name: Option<String>,
}
struct ScheduledInstancesPlacementSerializer;
impl ScheduledInstancesPlacementSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesPlacement) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledInstancesPrivateIpAddressConfig {
pub primary: Option<bool>,
pub private_ip_address: Option<String>,
}
struct ScheduledInstancesPrivateIpAddressConfigSerializer;
impl ScheduledInstancesPrivateIpAddressConfigSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledInstancesPrivateIpAddressConfig) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.primary {
params.put(&format!("{}{}", prefix, "Primary"), &field_value);
}
if let Some(ref field_value) = obj.private_ip_address {
params.put(&format!("{}{}", prefix, "PrivateIpAddress"), &field_value);
}
}
}
struct ScheduledInstancesSecurityGroupIdSetSerializer;
impl ScheduledInstancesSecurityGroupIdSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ScopeDeserializer;
impl ScopeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SearchTransitGatewayRoutesRequest {
pub dry_run: Option<bool>,
pub filters: Vec<Filter>,
pub max_results: Option<i64>,
pub transit_gateway_route_table_id: String,
}
struct SearchTransitGatewayRoutesRequestSerializer;
impl SearchTransitGatewayRoutesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SearchTransitGatewayRoutesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
FilterListSerializer::serialize(params, &format!("{}{}", prefix, "Filter"), &obj.filters);
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TransitGatewayRouteTableId"),
&obj.transit_gateway_route_table_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SearchTransitGatewayRoutesResult {
pub additional_routes_available: Option<bool>,
pub routes: Option<Vec<TransitGatewayRoute>>,
}
struct SearchTransitGatewayRoutesResultDeserializer;
impl SearchTransitGatewayRoutesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SearchTransitGatewayRoutesResult, XmlParseError> {
deserialize_elements::<_, SearchTransitGatewayRoutesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"additionalRoutesAvailable" => {
obj.additional_routes_available = Some(BooleanDeserializer::deserialize(
"additionalRoutesAvailable",
stack,
)?);
}
"routeSet" => {
obj.routes.get_or_insert(vec![]).extend(
TransitGatewayRouteListDeserializer::deserialize("routeSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SecurityGroup {
pub description: Option<String>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub ip_permissions: Option<Vec<IpPermission>>,
pub ip_permissions_egress: Option<Vec<IpPermission>>,
pub owner_id: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct SecurityGroupDeserializer;
impl SecurityGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SecurityGroup, XmlParseError> {
deserialize_elements::<_, SecurityGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupDescription" => {
obj.description =
Some(StringDeserializer::deserialize("groupDescription", stack)?);
}
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"ipPermissions" => {
obj.ip_permissions.get_or_insert(vec![]).extend(
IpPermissionListDeserializer::deserialize("ipPermissions", stack)?,
);
}
"ipPermissionsEgress" => {
obj.ip_permissions_egress.get_or_insert(vec![]).extend(
IpPermissionListDeserializer::deserialize("ipPermissionsEgress", stack)?,
);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SecurityGroupIdStringListDeserializer;
impl SecurityGroupIdStringListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SecurityGroupId" {
obj.push(StringDeserializer::deserialize("SecurityGroupId", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SecurityGroupIdStringListSerializer;
impl SecurityGroupIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SecurityGroupIdentifier {
pub group_id: Option<String>,
pub group_name: Option<String>,
}
struct SecurityGroupIdentifierDeserializer;
impl SecurityGroupIdentifierDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SecurityGroupIdentifier, XmlParseError> {
deserialize_elements::<_, SecurityGroupIdentifier, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SecurityGroupListDeserializer;
impl SecurityGroupListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SecurityGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SecurityGroupDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SecurityGroupReference {
pub group_id: Option<String>,
pub referencing_vpc_id: Option<String>,
pub vpc_peering_connection_id: Option<String>,
}
struct SecurityGroupReferenceDeserializer;
impl SecurityGroupReferenceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SecurityGroupReference, XmlParseError> {
deserialize_elements::<_, SecurityGroupReference, _>(tag_name, stack, |name, stack, obj| {
match name {
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"referencingVpcId" => {
obj.referencing_vpc_id =
Some(StringDeserializer::deserialize("referencingVpcId", stack)?);
}
"vpcPeeringConnectionId" => {
obj.vpc_peering_connection_id = Some(StringDeserializer::deserialize(
"vpcPeeringConnectionId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SecurityGroupReferencesDeserializer;
impl SecurityGroupReferencesDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SecurityGroupReference>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SecurityGroupReferenceDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SecurityGroupStringListSerializer;
impl SecurityGroupStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ServiceConfiguration {
pub acceptance_required: Option<bool>,
pub availability_zones: Option<Vec<String>>,
pub base_endpoint_dns_names: Option<Vec<String>>,
pub manages_vpc_endpoints: Option<bool>,
pub network_load_balancer_arns: Option<Vec<String>>,
pub private_dns_name: Option<String>,
pub service_id: Option<String>,
pub service_name: Option<String>,
pub service_state: Option<String>,
pub service_type: Option<Vec<ServiceTypeDetail>>,
pub tags: Option<Vec<Tag>>,
}
struct ServiceConfigurationDeserializer;
impl ServiceConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceConfiguration, XmlParseError> {
deserialize_elements::<_, ServiceConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"acceptanceRequired" => {
obj.acceptance_required = Some(BooleanDeserializer::deserialize(
"acceptanceRequired",
stack,
)?);
}
"availabilityZoneSet" => {
obj.availability_zones.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("availabilityZoneSet", stack)?,
);
}
"baseEndpointDnsNameSet" => {
obj.base_endpoint_dns_names.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("baseEndpointDnsNameSet", stack)?,
);
}
"managesVpcEndpoints" => {
obj.manages_vpc_endpoints = Some(BooleanDeserializer::deserialize(
"managesVpcEndpoints",
stack,
)?);
}
"networkLoadBalancerArnSet" => {
obj.network_load_balancer_arns.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize(
"networkLoadBalancerArnSet",
stack,
)?,
);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"serviceId" => {
obj.service_id = Some(StringDeserializer::deserialize("serviceId", stack)?);
}
"serviceName" => {
obj.service_name = Some(StringDeserializer::deserialize("serviceName", stack)?);
}
"serviceState" => {
obj.service_state = Some(ServiceStateDeserializer::deserialize(
"serviceState",
stack,
)?);
}
"serviceType" => {
obj.service_type.get_or_insert(vec![]).extend(
ServiceTypeDetailSetDeserializer::deserialize("serviceType", stack)?,
);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ServiceConfigurationSetDeserializer;
impl ServiceConfigurationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ServiceConfiguration>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ServiceConfigurationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ServiceDetail {
pub acceptance_required: Option<bool>,
pub availability_zones: Option<Vec<String>>,
pub base_endpoint_dns_names: Option<Vec<String>>,
pub manages_vpc_endpoints: Option<bool>,
pub owner: Option<String>,
pub private_dns_name: Option<String>,
pub service_id: Option<String>,
pub service_name: Option<String>,
pub service_type: Option<Vec<ServiceTypeDetail>>,
pub tags: Option<Vec<Tag>>,
pub vpc_endpoint_policy_supported: Option<bool>,
}
struct ServiceDetailDeserializer;
impl ServiceDetailDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceDetail, XmlParseError> {
deserialize_elements::<_, ServiceDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"acceptanceRequired" => {
obj.acceptance_required = Some(BooleanDeserializer::deserialize(
"acceptanceRequired",
stack,
)?);
}
"availabilityZoneSet" => {
obj.availability_zones.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("availabilityZoneSet", stack)?,
);
}
"baseEndpointDnsNameSet" => {
obj.base_endpoint_dns_names.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("baseEndpointDnsNameSet", stack)?,
);
}
"managesVpcEndpoints" => {
obj.manages_vpc_endpoints = Some(BooleanDeserializer::deserialize(
"managesVpcEndpoints",
stack,
)?);
}
"owner" => {
obj.owner = Some(StringDeserializer::deserialize("owner", stack)?);
}
"privateDnsName" => {
obj.private_dns_name =
Some(StringDeserializer::deserialize("privateDnsName", stack)?);
}
"serviceId" => {
obj.service_id = Some(StringDeserializer::deserialize("serviceId", stack)?);
}
"serviceName" => {
obj.service_name = Some(StringDeserializer::deserialize("serviceName", stack)?);
}
"serviceType" => {
obj.service_type.get_or_insert(vec![]).extend(
ServiceTypeDetailSetDeserializer::deserialize("serviceType", stack)?,
);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcEndpointPolicySupported" => {
obj.vpc_endpoint_policy_supported = Some(BooleanDeserializer::deserialize(
"vpcEndpointPolicySupported",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ServiceDetailSetDeserializer;
impl ServiceDetailSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ServiceDetail>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ServiceDetailDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ServiceStateDeserializer;
impl ServiceStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ServiceTypeDeserializer;
impl ServiceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ServiceTypeDetail {
pub service_type: Option<String>,
}
struct ServiceTypeDetailDeserializer;
impl ServiceTypeDetailDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceTypeDetail, XmlParseError> {
deserialize_elements::<_, ServiceTypeDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"serviceType" => {
obj.service_type =
Some(ServiceTypeDeserializer::deserialize("serviceType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ServiceTypeDetailSetDeserializer;
impl ServiceTypeDetailSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ServiceTypeDetail>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(ServiceTypeDetailDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ShutdownBehaviorDeserializer;
impl ShutdownBehaviorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SlotDateTimeRangeRequest {
pub earliest_time: String,
pub latest_time: String,
}
struct SlotDateTimeRangeRequestSerializer;
impl SlotDateTimeRangeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SlotDateTimeRangeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "EarliestTime"), &obj.earliest_time);
params.put(&format!("{}{}", prefix, "LatestTime"), &obj.latest_time);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SlotStartTimeRangeRequest {
pub earliest_time: Option<String>,
pub latest_time: Option<String>,
}
struct SlotStartTimeRangeRequestSerializer;
impl SlotStartTimeRangeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SlotStartTimeRangeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.earliest_time {
params.put(&format!("{}{}", prefix, "EarliestTime"), &field_value);
}
if let Some(ref field_value) = obj.latest_time {
params.put(&format!("{}{}", prefix, "LatestTime"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Snapshot {
pub data_encryption_key_id: Option<String>,
pub description: Option<String>,
pub encrypted: Option<bool>,
pub kms_key_id: Option<String>,
pub owner_alias: Option<String>,
pub owner_id: Option<String>,
pub progress: Option<String>,
pub snapshot_id: Option<String>,
pub start_time: Option<String>,
pub state: Option<String>,
pub state_message: Option<String>,
pub tags: Option<Vec<Tag>>,
pub volume_id: Option<String>,
pub volume_size: Option<i64>,
}
struct SnapshotDeserializer;
impl SnapshotDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Snapshot, XmlParseError> {
deserialize_elements::<_, Snapshot, _>(tag_name, stack, |name, stack, obj| {
match name {
"dataEncryptionKeyId" => {
obj.data_encryption_key_id = Some(StringDeserializer::deserialize(
"dataEncryptionKeyId",
stack,
)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
"ownerAlias" => {
obj.owner_alias = Some(StringDeserializer::deserialize("ownerAlias", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"startTime" => {
obj.start_time = Some(DateTimeDeserializer::deserialize("startTime", stack)?);
}
"status" => {
obj.state = Some(SnapshotStateDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.state_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
"volumeSize" => {
obj.volume_size = Some(IntegerDeserializer::deserialize("volumeSize", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotDetail {
pub description: Option<String>,
pub device_name: Option<String>,
pub disk_image_size: Option<f64>,
pub format: Option<String>,
pub progress: Option<String>,
pub snapshot_id: Option<String>,
pub status: Option<String>,
pub status_message: Option<String>,
pub url: Option<String>,
pub user_bucket: Option<UserBucketDetails>,
}
struct SnapshotDetailDeserializer;
impl SnapshotDetailDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotDetail, XmlParseError> {
deserialize_elements::<_, SnapshotDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"deviceName" => {
obj.device_name = Some(StringDeserializer::deserialize("deviceName", stack)?);
}
"diskImageSize" => {
obj.disk_image_size =
Some(DoubleDeserializer::deserialize("diskImageSize", stack)?);
}
"format" => {
obj.format = Some(StringDeserializer::deserialize("format", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"url" => {
obj.url = Some(StringDeserializer::deserialize("url", stack)?);
}
"userBucket" => {
obj.user_bucket = Some(UserBucketDetailsDeserializer::deserialize(
"userBucket",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SnapshotDetailListDeserializer;
impl SnapshotDetailListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotDetail>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SnapshotDetailDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotDiskContainer {
pub description: Option<String>,
pub format: Option<String>,
pub url: Option<String>,
pub user_bucket: Option<UserBucket>,
}
struct SnapshotDiskContainerSerializer;
impl SnapshotDiskContainerSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SnapshotDiskContainer) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.format {
params.put(&format!("{}{}", prefix, "Format"), &field_value);
}
if let Some(ref field_value) = obj.url {
params.put(&format!("{}{}", prefix, "Url"), &field_value);
}
if let Some(ref field_value) = obj.user_bucket {
UserBucketSerializer::serialize(
params,
&format!("{}{}", prefix, "UserBucket"),
field_value,
);
}
}
}
struct SnapshotIdStringListSerializer;
impl SnapshotIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotInfo {
pub description: Option<String>,
pub encrypted: Option<bool>,
pub owner_id: Option<String>,
pub progress: Option<String>,
pub snapshot_id: Option<String>,
pub start_time: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub volume_id: Option<String>,
pub volume_size: Option<i64>,
}
struct SnapshotInfoDeserializer;
impl SnapshotInfoDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotInfo, XmlParseError> {
deserialize_elements::<_, SnapshotInfo, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"startTime" => {
obj.start_time = Some(MillisecondDateTimeDeserializer::deserialize(
"startTime",
stack,
)?);
}
"state" => {
obj.state = Some(SnapshotStateDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
"volumeSize" => {
obj.volume_size = Some(IntegerDeserializer::deserialize("volumeSize", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SnapshotListDeserializer;
impl SnapshotListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Snapshot>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SnapshotDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SnapshotSetDeserializer;
impl SnapshotSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotInfo>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SnapshotInfoDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SnapshotStateDeserializer;
impl SnapshotStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotTaskDetail {
pub description: Option<String>,
pub disk_image_size: Option<f64>,
pub encrypted: Option<bool>,
pub format: Option<String>,
pub kms_key_id: Option<String>,
pub progress: Option<String>,
pub snapshot_id: Option<String>,
pub status: Option<String>,
pub status_message: Option<String>,
pub url: Option<String>,
pub user_bucket: Option<UserBucketDetails>,
}
struct SnapshotTaskDetailDeserializer;
impl SnapshotTaskDetailDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotTaskDetail, XmlParseError> {
deserialize_elements::<_, SnapshotTaskDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"diskImageSize" => {
obj.disk_image_size =
Some(DoubleDeserializer::deserialize("diskImageSize", stack)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"format" => {
obj.format = Some(StringDeserializer::deserialize("format", stack)?);
}
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
"progress" => {
obj.progress = Some(StringDeserializer::deserialize("progress", stack)?);
}
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"url" => {
obj.url = Some(StringDeserializer::deserialize("url", stack)?);
}
"userBucket" => {
obj.user_bucket = Some(UserBucketDetailsDeserializer::deserialize(
"userBucket",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SpotAllocationStrategyDeserializer;
impl SpotAllocationStrategyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotDatafeedSubscription {
pub bucket: Option<String>,
pub fault: Option<SpotInstanceStateFault>,
pub owner_id: Option<String>,
pub prefix: Option<String>,
pub state: Option<String>,
}
struct SpotDatafeedSubscriptionDeserializer;
impl SpotDatafeedSubscriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotDatafeedSubscription, XmlParseError> {
deserialize_elements::<_, SpotDatafeedSubscription, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"bucket" => {
obj.bucket = Some(StringDeserializer::deserialize("bucket", stack)?);
}
"fault" => {
obj.fault = Some(SpotInstanceStateFaultDeserializer::deserialize(
"fault", stack,
)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"prefix" => {
obj.prefix = Some(StringDeserializer::deserialize("prefix", stack)?);
}
"state" => {
obj.state = Some(DatafeedSubscriptionStateDeserializer::deserialize(
"state", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotFleetLaunchSpecification {
pub addressing_type: Option<String>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub ebs_optimized: Option<bool>,
pub iam_instance_profile: Option<IamInstanceProfileSpecification>,
pub image_id: Option<String>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub monitoring: Option<SpotFleetMonitoring>,
pub network_interfaces: Option<Vec<InstanceNetworkInterfaceSpecification>>,
pub placement: Option<SpotPlacement>,
pub ramdisk_id: Option<String>,
pub security_groups: Option<Vec<GroupIdentifier>>,
pub spot_price: Option<String>,
pub subnet_id: Option<String>,
pub tag_specifications: Option<Vec<SpotFleetTagSpecification>>,
pub user_data: Option<String>,
pub weighted_capacity: Option<f64>,
}
struct SpotFleetLaunchSpecificationDeserializer;
impl SpotFleetLaunchSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotFleetLaunchSpecification, XmlParseError> {
deserialize_elements::<_, SpotFleetLaunchSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"addressingType" => {
obj.addressing_type =
Some(StringDeserializer::deserialize("addressingType", stack)?);
}
"blockDeviceMapping" => {
obj.block_device_mappings.get_or_insert(vec![]).extend(
BlockDeviceMappingListDeserializer::deserialize(
"blockDeviceMapping",
stack,
)?,
);
}
"ebsOptimized" => {
obj.ebs_optimized =
Some(BooleanDeserializer::deserialize("ebsOptimized", stack)?);
}
"iamInstanceProfile" => {
obj.iam_instance_profile =
Some(IamInstanceProfileSpecificationDeserializer::deserialize(
"iamInstanceProfile",
stack,
)?);
}
"imageId" => {
obj.image_id = Some(StringDeserializer::deserialize("imageId", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"kernelId" => {
obj.kernel_id = Some(StringDeserializer::deserialize("kernelId", stack)?);
}
"keyName" => {
obj.key_name = Some(StringDeserializer::deserialize("keyName", stack)?);
}
"monitoring" => {
obj.monitoring = Some(SpotFleetMonitoringDeserializer::deserialize(
"monitoring",
stack,
)?);
}
"networkInterfaceSet" => {
obj.network_interfaces.get_or_insert(vec![]).extend(
InstanceNetworkInterfaceSpecificationListDeserializer::deserialize(
"networkInterfaceSet",
stack,
)?,
);
}
"placement" => {
obj.placement =
Some(SpotPlacementDeserializer::deserialize("placement", stack)?);
}
"ramdiskId" => {
obj.ramdisk_id = Some(StringDeserializer::deserialize("ramdiskId", stack)?);
}
"groupSet" => {
obj.security_groups.get_or_insert(vec![]).extend(
GroupIdentifierListDeserializer::deserialize("groupSet", stack)?,
);
}
"spotPrice" => {
obj.spot_price = Some(StringDeserializer::deserialize("spotPrice", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"tagSpecificationSet" => {
obj.tag_specifications.get_or_insert(vec![]).extend(
SpotFleetTagSpecificationListDeserializer::deserialize(
"tagSpecificationSet",
stack,
)?,
);
}
"userData" => {
obj.user_data = Some(StringDeserializer::deserialize("userData", stack)?);
}
"weightedCapacity" => {
obj.weighted_capacity =
Some(DoubleDeserializer::deserialize("weightedCapacity", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SpotFleetLaunchSpecificationSerializer;
impl SpotFleetLaunchSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotFleetLaunchSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.addressing_type {
params.put(&format!("{}{}", prefix, "AddressingType"), &field_value);
}
if let Some(ref field_value) = obj.block_device_mappings {
BlockDeviceMappingListSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMapping"),
field_value,
);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(&format!("{}{}", prefix, "EbsOptimized"), &field_value);
}
if let Some(ref field_value) = obj.iam_instance_profile {
IamInstanceProfileSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "IamInstanceProfile"),
field_value,
);
}
if let Some(ref field_value) = obj.image_id {
params.put(&format!("{}{}", prefix, "ImageId"), &field_value);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
if let Some(ref field_value) = obj.key_name {
params.put(&format!("{}{}", prefix, "KeyName"), &field_value);
}
if let Some(ref field_value) = obj.monitoring {
SpotFleetMonitoringSerializer::serialize(
params,
&format!("{}{}", prefix, "Monitoring"),
field_value,
);
}
if let Some(ref field_value) = obj.network_interfaces {
InstanceNetworkInterfaceSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "NetworkInterfaceSet"),
field_value,
);
}
if let Some(ref field_value) = obj.placement {
SpotPlacementSerializer::serialize(
params,
&format!("{}{}", prefix, "Placement"),
field_value,
);
}
if let Some(ref field_value) = obj.ramdisk_id {
params.put(&format!("{}{}", prefix, "RamdiskId"), &field_value);
}
if let Some(ref field_value) = obj.security_groups {
GroupIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "GroupSet"),
field_value,
);
}
if let Some(ref field_value) = obj.spot_price {
params.put(&format!("{}{}", prefix, "SpotPrice"), &field_value);
}
if let Some(ref field_value) = obj.subnet_id {
params.put(&format!("{}{}", prefix, "SubnetId"), &field_value);
}
if let Some(ref field_value) = obj.tag_specifications {
SpotFleetTagSpecificationListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagSpecificationSet"),
field_value,
);
}
if let Some(ref field_value) = obj.user_data {
params.put(&format!("{}{}", prefix, "UserData"), &field_value);
}
if let Some(ref field_value) = obj.weighted_capacity {
params.put(&format!("{}{}", prefix, "WeightedCapacity"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotFleetMonitoring {
pub enabled: Option<bool>,
}
struct SpotFleetMonitoringDeserializer;
impl SpotFleetMonitoringDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotFleetMonitoring, XmlParseError> {
deserialize_elements::<_, SpotFleetMonitoring, _>(tag_name, stack, |name, stack, obj| {
match name {
"enabled" => {
obj.enabled = Some(BooleanDeserializer::deserialize("enabled", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SpotFleetMonitoringSerializer;
impl SpotFleetMonitoringSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotFleetMonitoring) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotFleetRequestConfig {
pub activity_status: Option<String>,
pub create_time: Option<String>,
pub spot_fleet_request_config: Option<SpotFleetRequestConfigData>,
pub spot_fleet_request_id: Option<String>,
pub spot_fleet_request_state: Option<String>,
}
struct SpotFleetRequestConfigDeserializer;
impl SpotFleetRequestConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotFleetRequestConfig, XmlParseError> {
deserialize_elements::<_, SpotFleetRequestConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"activityStatus" => {
obj.activity_status = Some(ActivityStatusDeserializer::deserialize(
"activityStatus",
stack,
)?);
}
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"spotFleetRequestConfig" => {
obj.spot_fleet_request_config =
Some(SpotFleetRequestConfigDataDeserializer::deserialize(
"spotFleetRequestConfig",
stack,
)?);
}
"spotFleetRequestId" => {
obj.spot_fleet_request_id = Some(StringDeserializer::deserialize(
"spotFleetRequestId",
stack,
)?);
}
"spotFleetRequestState" => {
obj.spot_fleet_request_state = Some(BatchStateDeserializer::deserialize(
"spotFleetRequestState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotFleetRequestConfigData {
pub allocation_strategy: Option<String>,
pub client_token: Option<String>,
pub excess_capacity_termination_policy: Option<String>,
pub fulfilled_capacity: Option<f64>,
pub iam_fleet_role: String,
pub instance_interruption_behavior: Option<String>,
pub instance_pools_to_use_count: Option<i64>,
pub launch_specifications: Option<Vec<SpotFleetLaunchSpecification>>,
pub launch_template_configs: Option<Vec<LaunchTemplateConfig>>,
pub load_balancers_config: Option<LoadBalancersConfig>,
pub on_demand_allocation_strategy: Option<String>,
pub on_demand_fulfilled_capacity: Option<f64>,
pub on_demand_target_capacity: Option<i64>,
pub replace_unhealthy_instances: Option<bool>,
pub spot_price: Option<String>,
pub target_capacity: i64,
pub terminate_instances_with_expiration: Option<bool>,
pub type_: Option<String>,
pub valid_from: Option<String>,
pub valid_until: Option<String>,
}
struct SpotFleetRequestConfigDataDeserializer;
impl SpotFleetRequestConfigDataDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotFleetRequestConfigData, XmlParseError> {
deserialize_elements::<_, SpotFleetRequestConfigData, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"allocationStrategy" => {
obj.allocation_strategy =
Some(AllocationStrategyDeserializer::deserialize(
"allocationStrategy",
stack,
)?);
}
"clientToken" => {
obj.client_token =
Some(StringDeserializer::deserialize("clientToken", stack)?);
}
"excessCapacityTerminationPolicy" => {
obj.excess_capacity_termination_policy =
Some(ExcessCapacityTerminationPolicyDeserializer::deserialize(
"excessCapacityTerminationPolicy",
stack,
)?);
}
"fulfilledCapacity" => {
obj.fulfilled_capacity =
Some(DoubleDeserializer::deserialize("fulfilledCapacity", stack)?);
}
"iamFleetRole" => {
obj.iam_fleet_role =
StringDeserializer::deserialize("iamFleetRole", stack)?;
}
"instanceInterruptionBehavior" => {
obj.instance_interruption_behavior =
Some(InstanceInterruptionBehaviorDeserializer::deserialize(
"instanceInterruptionBehavior",
stack,
)?);
}
"instancePoolsToUseCount" => {
obj.instance_pools_to_use_count = Some(IntegerDeserializer::deserialize(
"instancePoolsToUseCount",
stack,
)?);
}
"launchSpecifications" => {
obj.launch_specifications.get_or_insert(vec![]).extend(
LaunchSpecsListDeserializer::deserialize(
"launchSpecifications",
stack,
)?,
);
}
"launchTemplateConfigs" => {
obj.launch_template_configs.get_or_insert(vec![]).extend(
LaunchTemplateConfigListDeserializer::deserialize(
"launchTemplateConfigs",
stack,
)?,
);
}
"loadBalancersConfig" => {
obj.load_balancers_config =
Some(LoadBalancersConfigDeserializer::deserialize(
"loadBalancersConfig",
stack,
)?);
}
"onDemandAllocationStrategy" => {
obj.on_demand_allocation_strategy =
Some(OnDemandAllocationStrategyDeserializer::deserialize(
"onDemandAllocationStrategy",
stack,
)?);
}
"onDemandFulfilledCapacity" => {
obj.on_demand_fulfilled_capacity = Some(DoubleDeserializer::deserialize(
"onDemandFulfilledCapacity",
stack,
)?);
}
"onDemandTargetCapacity" => {
obj.on_demand_target_capacity = Some(IntegerDeserializer::deserialize(
"onDemandTargetCapacity",
stack,
)?);
}
"replaceUnhealthyInstances" => {
obj.replace_unhealthy_instances = Some(BooleanDeserializer::deserialize(
"replaceUnhealthyInstances",
stack,
)?);
}
"spotPrice" => {
obj.spot_price = Some(StringDeserializer::deserialize("spotPrice", stack)?);
}
"targetCapacity" => {
obj.target_capacity =
IntegerDeserializer::deserialize("targetCapacity", stack)?;
}
"terminateInstancesWithExpiration" => {
obj.terminate_instances_with_expiration =
Some(BooleanDeserializer::deserialize(
"terminateInstancesWithExpiration",
stack,
)?);
}
"type" => {
obj.type_ = Some(FleetTypeDeserializer::deserialize("type", stack)?);
}
"validFrom" => {
obj.valid_from =
Some(DateTimeDeserializer::deserialize("validFrom", stack)?);
}
"validUntil" => {
obj.valid_until =
Some(DateTimeDeserializer::deserialize("validUntil", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SpotFleetRequestConfigDataSerializer;
impl SpotFleetRequestConfigDataSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotFleetRequestConfigData) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocation_strategy {
params.put(&format!("{}{}", prefix, "AllocationStrategy"), &field_value);
}
if let Some(ref field_value) = obj.client_token {
params.put(&format!("{}{}", prefix, "ClientToken"), &field_value);
}
if let Some(ref field_value) = obj.excess_capacity_termination_policy {
params.put(
&format!("{}{}", prefix, "ExcessCapacityTerminationPolicy"),
&field_value,
);
}
if let Some(ref field_value) = obj.fulfilled_capacity {
params.put(&format!("{}{}", prefix, "FulfilledCapacity"), &field_value);
}
params.put(
&format!("{}{}", prefix, "IamFleetRole"),
&obj.iam_fleet_role,
);
if let Some(ref field_value) = obj.instance_interruption_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInterruptionBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_pools_to_use_count {
params.put(
&format!("{}{}", prefix, "InstancePoolsToUseCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.launch_specifications {
LaunchSpecsListSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchSpecifications"),
field_value,
);
}
if let Some(ref field_value) = obj.launch_template_configs {
LaunchTemplateConfigListSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateConfigs"),
field_value,
);
}
if let Some(ref field_value) = obj.load_balancers_config {
LoadBalancersConfigSerializer::serialize(
params,
&format!("{}{}", prefix, "LoadBalancersConfig"),
field_value,
);
}
if let Some(ref field_value) = obj.on_demand_allocation_strategy {
params.put(
&format!("{}{}", prefix, "OnDemandAllocationStrategy"),
&field_value,
);
}
if let Some(ref field_value) = obj.on_demand_fulfilled_capacity {
params.put(
&format!("{}{}", prefix, "OnDemandFulfilledCapacity"),
&field_value,
);
}
if let Some(ref field_value) = obj.on_demand_target_capacity {
params.put(
&format!("{}{}", prefix, "OnDemandTargetCapacity"),
&field_value,
);
}
if let Some(ref field_value) = obj.replace_unhealthy_instances {
params.put(
&format!("{}{}", prefix, "ReplaceUnhealthyInstances"),
&field_value,
);
}
if let Some(ref field_value) = obj.spot_price {
params.put(&format!("{}{}", prefix, "SpotPrice"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TargetCapacity"),
&obj.target_capacity,
);
if let Some(ref field_value) = obj.terminate_instances_with_expiration {
params.put(
&format!("{}{}", prefix, "TerminateInstancesWithExpiration"),
&field_value,
);
}
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.valid_from {
params.put(&format!("{}{}", prefix, "ValidFrom"), &field_value);
}
if let Some(ref field_value) = obj.valid_until {
params.put(&format!("{}{}", prefix, "ValidUntil"), &field_value);
}
}
}
struct SpotFleetRequestConfigSetDeserializer;
impl SpotFleetRequestConfigSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SpotFleetRequestConfig>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SpotFleetRequestConfigDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotFleetTagSpecification {
pub resource_type: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct SpotFleetTagSpecificationDeserializer;
impl SpotFleetTagSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotFleetTagSpecification, XmlParseError> {
deserialize_elements::<_, SpotFleetTagSpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceType" => {
obj.resource_type = Some(ResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?);
}
"tag" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tag", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SpotFleetTagSpecificationSerializer;
impl SpotFleetTagSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotFleetTagSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.resource_type {
params.put(&format!("{}{}", prefix, "ResourceType"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
struct SpotFleetTagSpecificationListDeserializer;
impl SpotFleetTagSpecificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SpotFleetTagSpecification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SpotFleetTagSpecificationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SpotFleetTagSpecificationListSerializer;
impl SpotFleetTagSpecificationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<SpotFleetTagSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
SpotFleetTagSpecificationSerializer::serialize(params, &key, obj);
}
}
}
struct SpotInstanceInterruptionBehaviorDeserializer;
impl SpotInstanceInterruptionBehaviorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotInstanceRequest {
pub actual_block_hourly_price: Option<String>,
pub availability_zone_group: Option<String>,
pub block_duration_minutes: Option<i64>,
pub create_time: Option<String>,
pub fault: Option<SpotInstanceStateFault>,
pub instance_id: Option<String>,
pub instance_interruption_behavior: Option<String>,
pub launch_group: Option<String>,
pub launch_specification: Option<LaunchSpecification>,
pub launched_availability_zone: Option<String>,
pub product_description: Option<String>,
pub spot_instance_request_id: Option<String>,
pub spot_price: Option<String>,
pub state: Option<String>,
pub status: Option<SpotInstanceStatus>,
pub tags: Option<Vec<Tag>>,
pub type_: Option<String>,
pub valid_from: Option<String>,
pub valid_until: Option<String>,
}
struct SpotInstanceRequestDeserializer;
impl SpotInstanceRequestDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotInstanceRequest, XmlParseError> {
deserialize_elements::<_, SpotInstanceRequest, _>(tag_name, stack, |name, stack, obj| {
match name {
"actualBlockHourlyPrice" => {
obj.actual_block_hourly_price = Some(StringDeserializer::deserialize(
"actualBlockHourlyPrice",
stack,
)?);
}
"availabilityZoneGroup" => {
obj.availability_zone_group = Some(StringDeserializer::deserialize(
"availabilityZoneGroup",
stack,
)?);
}
"blockDurationMinutes" => {
obj.block_duration_minutes = Some(IntegerDeserializer::deserialize(
"blockDurationMinutes",
stack,
)?);
}
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"fault" => {
obj.fault = Some(SpotInstanceStateFaultDeserializer::deserialize(
"fault", stack,
)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"instanceInterruptionBehavior" => {
obj.instance_interruption_behavior =
Some(InstanceInterruptionBehaviorDeserializer::deserialize(
"instanceInterruptionBehavior",
stack,
)?);
}
"launchGroup" => {
obj.launch_group = Some(StringDeserializer::deserialize("launchGroup", stack)?);
}
"launchSpecification" => {
obj.launch_specification = Some(LaunchSpecificationDeserializer::deserialize(
"launchSpecification",
stack,
)?);
}
"launchedAvailabilityZone" => {
obj.launched_availability_zone = Some(StringDeserializer::deserialize(
"launchedAvailabilityZone",
stack,
)?);
}
"productDescription" => {
obj.product_description = Some(RIProductDescriptionDeserializer::deserialize(
"productDescription",
stack,
)?);
}
"spotInstanceRequestId" => {
obj.spot_instance_request_id = Some(StringDeserializer::deserialize(
"spotInstanceRequestId",
stack,
)?);
}
"spotPrice" => {
obj.spot_price = Some(StringDeserializer::deserialize("spotPrice", stack)?);
}
"state" => {
obj.state = Some(SpotInstanceStateDeserializer::deserialize("state", stack)?);
}
"status" => {
obj.status = Some(SpotInstanceStatusDeserializer::deserialize(
"status", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"type" => {
obj.type_ = Some(SpotInstanceTypeDeserializer::deserialize("type", stack)?);
}
"validFrom" => {
obj.valid_from = Some(DateTimeDeserializer::deserialize("validFrom", stack)?);
}
"validUntil" => {
obj.valid_until = Some(DateTimeDeserializer::deserialize("validUntil", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SpotInstanceRequestIdListSerializer;
impl SpotInstanceRequestIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct SpotInstanceRequestListDeserializer;
impl SpotInstanceRequestListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SpotInstanceRequest>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SpotInstanceRequestDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SpotInstanceStateDeserializer;
impl SpotInstanceStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotInstanceStateFault {
pub code: Option<String>,
pub message: Option<String>,
}
struct SpotInstanceStateFaultDeserializer;
impl SpotInstanceStateFaultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotInstanceStateFault, XmlParseError> {
deserialize_elements::<_, SpotInstanceStateFault, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(StringDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotInstanceStatus {
pub code: Option<String>,
pub message: Option<String>,
pub update_time: Option<String>,
}
struct SpotInstanceStatusDeserializer;
impl SpotInstanceStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotInstanceStatus, XmlParseError> {
deserialize_elements::<_, SpotInstanceStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(StringDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
"updateTime" => {
obj.update_time = Some(DateTimeDeserializer::deserialize("updateTime", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SpotInstanceTypeDeserializer;
impl SpotInstanceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotMarketOptions {
pub block_duration_minutes: Option<i64>,
pub instance_interruption_behavior: Option<String>,
pub max_price: Option<String>,
pub spot_instance_type: Option<String>,
pub valid_until: Option<String>,
}
struct SpotMarketOptionsSerializer;
impl SpotMarketOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotMarketOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.block_duration_minutes {
params.put(
&format!("{}{}", prefix, "BlockDurationMinutes"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_interruption_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInterruptionBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.max_price {
params.put(&format!("{}{}", prefix, "MaxPrice"), &field_value);
}
if let Some(ref field_value) = obj.spot_instance_type {
params.put(&format!("{}{}", prefix, "SpotInstanceType"), &field_value);
}
if let Some(ref field_value) = obj.valid_until {
params.put(&format!("{}{}", prefix, "ValidUntil"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotOptions {
pub allocation_strategy: Option<String>,
pub instance_interruption_behavior: Option<String>,
pub instance_pools_to_use_count: Option<i64>,
pub min_target_capacity: Option<i64>,
pub single_availability_zone: Option<bool>,
pub single_instance_type: Option<bool>,
}
struct SpotOptionsDeserializer;
impl SpotOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotOptions, XmlParseError> {
deserialize_elements::<_, SpotOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"allocationStrategy" => {
obj.allocation_strategy =
Some(SpotAllocationStrategyDeserializer::deserialize(
"allocationStrategy",
stack,
)?);
}
"instanceInterruptionBehavior" => {
obj.instance_interruption_behavior =
Some(SpotInstanceInterruptionBehaviorDeserializer::deserialize(
"instanceInterruptionBehavior",
stack,
)?);
}
"instancePoolsToUseCount" => {
obj.instance_pools_to_use_count = Some(IntegerDeserializer::deserialize(
"instancePoolsToUseCount",
stack,
)?);
}
"minTargetCapacity" => {
obj.min_target_capacity = Some(IntegerDeserializer::deserialize(
"minTargetCapacity",
stack,
)?);
}
"singleAvailabilityZone" => {
obj.single_availability_zone = Some(BooleanDeserializer::deserialize(
"singleAvailabilityZone",
stack,
)?);
}
"singleInstanceType" => {
obj.single_instance_type = Some(BooleanDeserializer::deserialize(
"singleInstanceType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotOptionsRequest {
pub allocation_strategy: Option<String>,
pub instance_interruption_behavior: Option<String>,
pub instance_pools_to_use_count: Option<i64>,
pub min_target_capacity: Option<i64>,
pub single_availability_zone: Option<bool>,
pub single_instance_type: Option<bool>,
}
struct SpotOptionsRequestSerializer;
impl SpotOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocation_strategy {
params.put(&format!("{}{}", prefix, "AllocationStrategy"), &field_value);
}
if let Some(ref field_value) = obj.instance_interruption_behavior {
params.put(
&format!("{}{}", prefix, "InstanceInterruptionBehavior"),
&field_value,
);
}
if let Some(ref field_value) = obj.instance_pools_to_use_count {
params.put(
&format!("{}{}", prefix, "InstancePoolsToUseCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.min_target_capacity {
params.put(&format!("{}{}", prefix, "MinTargetCapacity"), &field_value);
}
if let Some(ref field_value) = obj.single_availability_zone {
params.put(
&format!("{}{}", prefix, "SingleAvailabilityZone"),
&field_value,
);
}
if let Some(ref field_value) = obj.single_instance_type {
params.put(&format!("{}{}", prefix, "SingleInstanceType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotPlacement {
pub availability_zone: Option<String>,
pub group_name: Option<String>,
pub tenancy: Option<String>,
}
struct SpotPlacementDeserializer;
impl SpotPlacementDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotPlacement, XmlParseError> {
deserialize_elements::<_, SpotPlacement, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"tenancy" => {
obj.tenancy = Some(TenancyDeserializer::deserialize("tenancy", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SpotPlacementSerializer;
impl SpotPlacementSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SpotPlacement) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.tenancy {
params.put(&format!("{}{}", prefix, "Tenancy"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SpotPrice {
pub availability_zone: Option<String>,
pub instance_type: Option<String>,
pub product_description: Option<String>,
pub spot_price: Option<String>,
pub timestamp: Option<String>,
}
struct SpotPriceDeserializer;
impl SpotPriceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SpotPrice, XmlParseError> {
deserialize_elements::<_, SpotPrice, _>(tag_name, stack, |name, stack, obj| {
match name {
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"instanceType" => {
obj.instance_type = Some(InstanceTypeDeserializer::deserialize(
"instanceType",
stack,
)?);
}
"productDescription" => {
obj.product_description = Some(RIProductDescriptionDeserializer::deserialize(
"productDescription",
stack,
)?);
}
"spotPrice" => {
obj.spot_price = Some(StringDeserializer::deserialize("spotPrice", stack)?);
}
"timestamp" => {
obj.timestamp = Some(DateTimeDeserializer::deserialize("timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SpotPriceHistoryListDeserializer;
impl SpotPriceHistoryListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SpotPrice>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SpotPriceDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StaleIpPermission {
pub from_port: Option<i64>,
pub ip_protocol: Option<String>,
pub ip_ranges: Option<Vec<String>>,
pub prefix_list_ids: Option<Vec<String>>,
pub to_port: Option<i64>,
pub user_id_group_pairs: Option<Vec<UserIdGroupPair>>,
}
struct StaleIpPermissionDeserializer;
impl StaleIpPermissionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StaleIpPermission, XmlParseError> {
deserialize_elements::<_, StaleIpPermission, _>(tag_name, stack, |name, stack, obj| {
match name {
"fromPort" => {
obj.from_port = Some(IntegerDeserializer::deserialize("fromPort", stack)?);
}
"ipProtocol" => {
obj.ip_protocol = Some(StringDeserializer::deserialize("ipProtocol", stack)?);
}
"ipRanges" => {
obj.ip_ranges
.get_or_insert(vec![])
.extend(IpRangesDeserializer::deserialize("ipRanges", stack)?);
}
"prefixListIds" => {
obj.prefix_list_ids.get_or_insert(vec![]).extend(
PrefixListIdSetDeserializer::deserialize("prefixListIds", stack)?,
);
}
"toPort" => {
obj.to_port = Some(IntegerDeserializer::deserialize("toPort", stack)?);
}
"groups" => {
obj.user_id_group_pairs.get_or_insert(vec![]).extend(
UserIdGroupPairSetDeserializer::deserialize("groups", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct StaleIpPermissionSetDeserializer;
impl StaleIpPermissionSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StaleIpPermission>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StaleIpPermissionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StaleSecurityGroup {
pub description: Option<String>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub stale_ip_permissions: Option<Vec<StaleIpPermission>>,
pub stale_ip_permissions_egress: Option<Vec<StaleIpPermission>>,
pub vpc_id: Option<String>,
}
struct StaleSecurityGroupDeserializer;
impl StaleSecurityGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StaleSecurityGroup, XmlParseError> {
deserialize_elements::<_, StaleSecurityGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"staleIpPermissions" => {
obj.stale_ip_permissions.get_or_insert(vec![]).extend(
StaleIpPermissionSetDeserializer::deserialize("staleIpPermissions", stack)?,
);
}
"staleIpPermissionsEgress" => {
obj.stale_ip_permissions_egress
.get_or_insert(vec![])
.extend(StaleIpPermissionSetDeserializer::deserialize(
"staleIpPermissionsEgress",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct StaleSecurityGroupSetDeserializer;
impl StaleSecurityGroupSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StaleSecurityGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StaleSecurityGroupDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StartInstancesRequest {
pub additional_info: Option<String>,
pub dry_run: Option<bool>,
pub instance_ids: Vec<String>,
}
struct StartInstancesRequestSerializer;
impl StartInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StartInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.additional_info {
params.put(&format!("{}{}", prefix, "AdditionalInfo"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instance_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StartInstancesResult {
pub starting_instances: Option<Vec<InstanceStateChange>>,
}
struct StartInstancesResultDeserializer;
impl StartInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StartInstancesResult, XmlParseError> {
deserialize_elements::<_, StartInstancesResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"instancesSet" => {
obj.starting_instances.get_or_insert(vec![]).extend(
InstanceStateChangeListDeserializer::deserialize("instancesSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct StateDeserializer;
impl StateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StateReason {
pub code: Option<String>,
pub message: Option<String>,
}
struct StateReasonDeserializer;
impl StateReasonDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StateReason, XmlParseError> {
deserialize_elements::<_, StateReason, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(StringDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct StatusDeserializer;
impl StatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct StatusNameDeserializer;
impl StatusNameDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct StatusTypeDeserializer;
impl StatusTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StopInstancesRequest {
pub dry_run: Option<bool>,
pub force: Option<bool>,
pub hibernate: Option<bool>,
pub instance_ids: Vec<String>,
}
struct StopInstancesRequestSerializer;
impl StopInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StopInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
if let Some(ref field_value) = obj.hibernate {
params.put(&format!("{}{}", prefix, "Hibernate"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instance_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StopInstancesResult {
pub stopping_instances: Option<Vec<InstanceStateChange>>,
}
struct StopInstancesResultDeserializer;
impl StopInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StopInstancesResult, XmlParseError> {
deserialize_elements::<_, StopInstancesResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"instancesSet" => {
obj.stopping_instances.get_or_insert(vec![]).extend(
InstanceStateChangeListDeserializer::deserialize("instancesSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Storage {
pub s3: Option<S3Storage>,
}
struct StorageDeserializer;
impl StorageDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Storage, XmlParseError> {
deserialize_elements::<_, Storage, _>(tag_name, stack, |name, stack, obj| {
match name {
"S3" => {
obj.s3 = Some(S3StorageDeserializer::deserialize("S3", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct StorageSerializer;
impl StorageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Storage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.s3 {
S3StorageSerializer::serialize(params, &format!("{}{}", prefix, "S3"), field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StorageLocation {
pub bucket: Option<String>,
pub key: Option<String>,
}
struct StorageLocationSerializer;
impl StorageLocationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StorageLocation) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.bucket {
params.put(&format!("{}{}", prefix, "Bucket"), &field_value);
}
if let Some(ref field_value) = obj.key {
params.put(&format!("{}{}", prefix, "Key"), &field_value);
}
}
}
struct StringDeserializer;
impl StringDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Subnet {
pub assign_ipv_6_address_on_creation: Option<bool>,
pub availability_zone: Option<String>,
pub availability_zone_id: Option<String>,
pub available_ip_address_count: Option<i64>,
pub cidr_block: Option<String>,
pub default_for_az: Option<bool>,
pub ipv_6_cidr_block_association_set: Option<Vec<SubnetIpv6CidrBlockAssociation>>,
pub map_public_ip_on_launch: Option<bool>,
pub owner_id: Option<String>,
pub state: Option<String>,
pub subnet_arn: Option<String>,
pub subnet_id: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct SubnetDeserializer;
impl SubnetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Subnet, XmlParseError> {
deserialize_elements::<_, Subnet, _>(tag_name, stack, |name, stack, obj| {
match name {
"assignIpv6AddressOnCreation" => {
obj.assign_ipv_6_address_on_creation = Some(BooleanDeserializer::deserialize(
"assignIpv6AddressOnCreation",
stack,
)?);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"availabilityZoneId" => {
obj.availability_zone_id = Some(StringDeserializer::deserialize(
"availabilityZoneId",
stack,
)?);
}
"availableIpAddressCount" => {
obj.available_ip_address_count = Some(IntegerDeserializer::deserialize(
"availableIpAddressCount",
stack,
)?);
}
"cidrBlock" => {
obj.cidr_block = Some(StringDeserializer::deserialize("cidrBlock", stack)?);
}
"defaultForAz" => {
obj.default_for_az =
Some(BooleanDeserializer::deserialize("defaultForAz", stack)?);
}
"ipv6CidrBlockAssociationSet" => {
obj.ipv_6_cidr_block_association_set
.get_or_insert(vec![])
.extend(SubnetIpv6CidrBlockAssociationSetDeserializer::deserialize(
"ipv6CidrBlockAssociationSet",
stack,
)?);
}
"mapPublicIpOnLaunch" => {
obj.map_public_ip_on_launch = Some(BooleanDeserializer::deserialize(
"mapPublicIpOnLaunch",
stack,
)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"state" => {
obj.state = Some(SubnetStateDeserializer::deserialize("state", stack)?);
}
"subnetArn" => {
obj.subnet_arn = Some(StringDeserializer::deserialize("subnetArn", stack)?);
}
"subnetId" => {
obj.subnet_id = Some(StringDeserializer::deserialize("subnetId", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SubnetCidrBlockState {
pub state: Option<String>,
pub status_message: Option<String>,
}
struct SubnetCidrBlockStateDeserializer;
impl SubnetCidrBlockStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SubnetCidrBlockState, XmlParseError> {
deserialize_elements::<_, SubnetCidrBlockState, _>(tag_name, stack, |name, stack, obj| {
match name {
"state" => {
obj.state = Some(SubnetCidrBlockStateCodeDeserializer::deserialize(
"state", stack,
)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SubnetCidrBlockStateCodeDeserializer;
impl SubnetCidrBlockStateCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct SubnetIdStringListSerializer;
impl SubnetIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SubnetIpv6CidrBlockAssociation {
pub association_id: Option<String>,
pub ipv_6_cidr_block: Option<String>,
pub ipv_6_cidr_block_state: Option<SubnetCidrBlockState>,
}
struct SubnetIpv6CidrBlockAssociationDeserializer;
impl SubnetIpv6CidrBlockAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SubnetIpv6CidrBlockAssociation, XmlParseError> {
deserialize_elements::<_, SubnetIpv6CidrBlockAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"ipv6CidrBlock" => {
obj.ipv_6_cidr_block =
Some(StringDeserializer::deserialize("ipv6CidrBlock", stack)?);
}
"ipv6CidrBlockState" => {
obj.ipv_6_cidr_block_state =
Some(SubnetCidrBlockStateDeserializer::deserialize(
"ipv6CidrBlockState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SubnetIpv6CidrBlockAssociationSetDeserializer;
impl SubnetIpv6CidrBlockAssociationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SubnetIpv6CidrBlockAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SubnetIpv6CidrBlockAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SubnetListDeserializer;
impl SubnetListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Subnet>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(SubnetDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SubnetStateDeserializer;
impl SubnetStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SuccessfulInstanceCreditSpecificationItem {
pub instance_id: Option<String>,
}
struct SuccessfulInstanceCreditSpecificationItemDeserializer;
impl SuccessfulInstanceCreditSpecificationItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SuccessfulInstanceCreditSpecificationItem, XmlParseError> {
deserialize_elements::<_, SuccessfulInstanceCreditSpecificationItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SuccessfulInstanceCreditSpecificationSetDeserializer;
impl SuccessfulInstanceCreditSpecificationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SuccessfulInstanceCreditSpecificationItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
SuccessfulInstanceCreditSpecificationItemDeserializer::deserialize(
"item", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SummaryStatusDeserializer;
impl SummaryStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Tag {
pub key: Option<String>,
pub value: Option<String>,
}
struct TagDeserializer;
impl TagDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Tag, XmlParseError> {
deserialize_elements::<_, Tag, _>(tag_name, stack, |name, stack, obj| {
match name {
"key" => {
obj.key = Some(StringDeserializer::deserialize("key", stack)?);
}
"value" => {
obj.value = Some(StringDeserializer::deserialize("value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TagSerializer;
impl TagSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Tag) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.key {
params.put(&format!("{}{}", prefix, "Key"), &field_value);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TagDescription {
pub key: Option<String>,
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub value: Option<String>,
}
struct TagDescriptionDeserializer;
impl TagDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagDescription, XmlParseError> {
deserialize_elements::<_, TagDescription, _>(tag_name, stack, |name, stack, obj| {
match name {
"key" => {
obj.key = Some(StringDeserializer::deserialize("key", stack)?);
}
"resourceId" => {
obj.resource_id = Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(ResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?);
}
"value" => {
obj.value = Some(StringDeserializer::deserialize("value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TagDescriptionListDeserializer;
impl TagDescriptionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TagDescription>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TagDescriptionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TagDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TagListSerializer;
impl TagListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Tag>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
TagSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TagSpecification {
pub resource_type: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct TagSpecificationSerializer;
impl TagSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TagSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.resource_type {
params.put(&format!("{}{}", prefix, "ResourceType"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
struct TagSpecificationListSerializer;
impl TagSpecificationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<TagSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
TagSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetCapacitySpecification {
pub default_target_capacity_type: Option<String>,
pub on_demand_target_capacity: Option<i64>,
pub spot_target_capacity: Option<i64>,
pub total_target_capacity: Option<i64>,
}
struct TargetCapacitySpecificationDeserializer;
impl TargetCapacitySpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetCapacitySpecification, XmlParseError> {
deserialize_elements::<_, TargetCapacitySpecification, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"defaultTargetCapacityType" => {
obj.default_target_capacity_type =
Some(DefaultTargetCapacityTypeDeserializer::deserialize(
"defaultTargetCapacityType",
stack,
)?);
}
"onDemandTargetCapacity" => {
obj.on_demand_target_capacity = Some(IntegerDeserializer::deserialize(
"onDemandTargetCapacity",
stack,
)?);
}
"spotTargetCapacity" => {
obj.spot_target_capacity = Some(IntegerDeserializer::deserialize(
"spotTargetCapacity",
stack,
)?);
}
"totalTargetCapacity" => {
obj.total_target_capacity = Some(IntegerDeserializer::deserialize(
"totalTargetCapacity",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetCapacitySpecificationRequest {
pub default_target_capacity_type: Option<String>,
pub on_demand_target_capacity: Option<i64>,
pub spot_target_capacity: Option<i64>,
pub total_target_capacity: i64,
}
struct TargetCapacitySpecificationRequestSerializer;
impl TargetCapacitySpecificationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TargetCapacitySpecificationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_target_capacity_type {
params.put(
&format!("{}{}", prefix, "DefaultTargetCapacityType"),
&field_value,
);
}
if let Some(ref field_value) = obj.on_demand_target_capacity {
params.put(
&format!("{}{}", prefix, "OnDemandTargetCapacity"),
&field_value,
);
}
if let Some(ref field_value) = obj.spot_target_capacity {
params.put(&format!("{}{}", prefix, "SpotTargetCapacity"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TotalTargetCapacity"),
&obj.total_target_capacity,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetConfiguration {
pub instance_count: Option<i64>,
pub offering_id: Option<String>,
}
struct TargetConfigurationDeserializer;
impl TargetConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetConfiguration, XmlParseError> {
deserialize_elements::<_, TargetConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"instanceCount" => {
obj.instance_count =
Some(IntegerDeserializer::deserialize("instanceCount", stack)?);
}
"offeringId" => {
obj.offering_id = Some(StringDeserializer::deserialize("offeringId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetConfigurationRequest {
pub instance_count: Option<i64>,
pub offering_id: String,
}
struct TargetConfigurationRequestSerializer;
impl TargetConfigurationRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TargetConfigurationRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.instance_count {
params.put(&format!("{}{}", prefix, "InstanceCount"), &field_value);
}
params.put(&format!("{}{}", prefix, "OfferingId"), &obj.offering_id);
}
}
struct TargetConfigurationRequestSetSerializer;
impl TargetConfigurationRequestSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<TargetConfigurationRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
TargetConfigurationRequestSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetGroup {
pub arn: Option<String>,
}
struct TargetGroupDeserializer;
impl TargetGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetGroup, XmlParseError> {
deserialize_elements::<_, TargetGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"arn" => {
obj.arn = Some(StringDeserializer::deserialize("arn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TargetGroupSerializer;
impl TargetGroupSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TargetGroup) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.arn {
params.put(&format!("{}{}", prefix, "Arn"), &field_value);
}
}
}
struct TargetGroupsDeserializer;
impl TargetGroupsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TargetGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TargetGroupDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TargetGroupsSerializer;
impl TargetGroupsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<TargetGroup>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
TargetGroupSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetGroupsConfig {
pub target_groups: Option<Vec<TargetGroup>>,
}
struct TargetGroupsConfigDeserializer;
impl TargetGroupsConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetGroupsConfig, XmlParseError> {
deserialize_elements::<_, TargetGroupsConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"targetGroups" => {
obj.target_groups.get_or_insert(vec![]).extend(
TargetGroupsDeserializer::deserialize("targetGroups", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TargetGroupsConfigSerializer;
impl TargetGroupsConfigSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TargetGroupsConfig) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.target_groups {
TargetGroupsSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetGroups"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetNetwork {
pub association_id: Option<String>,
pub client_vpn_endpoint_id: Option<String>,
pub security_groups: Option<Vec<String>>,
pub status: Option<AssociationStatus>,
pub target_network_id: Option<String>,
pub vpc_id: Option<String>,
}
struct TargetNetworkDeserializer;
impl TargetNetworkDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetNetwork, XmlParseError> {
deserialize_elements::<_, TargetNetwork, _>(tag_name, stack, |name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"securityGroups" => {
obj.security_groups.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("securityGroups", stack)?,
);
}
"status" => {
obj.status = Some(AssociationStatusDeserializer::deserialize("status", stack)?);
}
"targetNetworkId" => {
obj.target_network_id =
Some(StringDeserializer::deserialize("targetNetworkId", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TargetNetworkSetDeserializer;
impl TargetNetworkSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TargetNetwork>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TargetNetworkDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetReservationValue {
pub reservation_value: Option<ReservationValue>,
pub target_configuration: Option<TargetConfiguration>,
}
struct TargetReservationValueDeserializer;
impl TargetReservationValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetReservationValue, XmlParseError> {
deserialize_elements::<_, TargetReservationValue, _>(tag_name, stack, |name, stack, obj| {
match name {
"reservationValue" => {
obj.reservation_value = Some(ReservationValueDeserializer::deserialize(
"reservationValue",
stack,
)?);
}
"targetConfiguration" => {
obj.target_configuration = Some(TargetConfigurationDeserializer::deserialize(
"targetConfiguration",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TargetReservationValueSetDeserializer;
impl TargetReservationValueSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TargetReservationValue>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TargetReservationValueDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TelemetryStatusDeserializer;
impl TelemetryStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TenancyDeserializer;
impl TenancyDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TerminateClientVpnConnectionsRequest {
pub client_vpn_endpoint_id: String,
pub connection_id: Option<String>,
pub dry_run: Option<bool>,
pub username: Option<String>,
}
struct TerminateClientVpnConnectionsRequestSerializer;
impl TerminateClientVpnConnectionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TerminateClientVpnConnectionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClientVpnEndpointId"),
&obj.client_vpn_endpoint_id,
);
if let Some(ref field_value) = obj.connection_id {
params.put(&format!("{}{}", prefix, "ConnectionId"), &field_value);
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.username {
params.put(&format!("{}{}", prefix, "Username"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TerminateClientVpnConnectionsResult {
pub client_vpn_endpoint_id: Option<String>,
pub connection_statuses: Option<Vec<TerminateConnectionStatus>>,
pub username: Option<String>,
}
struct TerminateClientVpnConnectionsResultDeserializer;
impl TerminateClientVpnConnectionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TerminateClientVpnConnectionsResult, XmlParseError> {
deserialize_elements::<_, TerminateClientVpnConnectionsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"clientVpnEndpointId" => {
obj.client_vpn_endpoint_id = Some(StringDeserializer::deserialize(
"clientVpnEndpointId",
stack,
)?);
}
"connectionStatuses" => {
obj.connection_statuses.get_or_insert(vec![]).extend(
TerminateConnectionStatusSetDeserializer::deserialize(
"connectionStatuses",
stack,
)?,
);
}
"username" => {
obj.username = Some(StringDeserializer::deserialize("username", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TerminateConnectionStatus {
pub connection_id: Option<String>,
pub current_status: Option<ClientVpnConnectionStatus>,
pub previous_status: Option<ClientVpnConnectionStatus>,
}
struct TerminateConnectionStatusDeserializer;
impl TerminateConnectionStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TerminateConnectionStatus, XmlParseError> {
deserialize_elements::<_, TerminateConnectionStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"connectionId" => {
obj.connection_id =
Some(StringDeserializer::deserialize("connectionId", stack)?);
}
"currentStatus" => {
obj.current_status =
Some(ClientVpnConnectionStatusDeserializer::deserialize(
"currentStatus",
stack,
)?);
}
"previousStatus" => {
obj.previous_status =
Some(ClientVpnConnectionStatusDeserializer::deserialize(
"previousStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TerminateConnectionStatusSetDeserializer;
impl TerminateConnectionStatusSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TerminateConnectionStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TerminateConnectionStatusDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TerminateInstancesRequest {
pub dry_run: Option<bool>,
pub instance_ids: Vec<String>,
}
struct TerminateInstancesRequestSerializer;
impl TerminateInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TerminateInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instance_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TerminateInstancesResult {
pub terminating_instances: Option<Vec<InstanceStateChange>>,
}
struct TerminateInstancesResultDeserializer;
impl TerminateInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TerminateInstancesResult, XmlParseError> {
deserialize_elements::<_, TerminateInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instancesSet" => {
obj.terminating_instances.get_or_insert(vec![]).extend(
InstanceStateChangeListDeserializer::deserialize(
"instancesSet",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TrafficTypeDeserializer;
impl TrafficTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGateway {
pub creation_time: Option<String>,
pub description: Option<String>,
pub options: Option<TransitGatewayOptions>,
pub owner_id: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub transit_gateway_arn: Option<String>,
pub transit_gateway_id: Option<String>,
}
struct TransitGatewayDeserializer;
impl TransitGatewayDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGateway, XmlParseError> {
deserialize_elements::<_, TransitGateway, _>(tag_name, stack, |name, stack, obj| {
match name {
"creationTime" => {
obj.creation_time =
Some(DateTimeDeserializer::deserialize("creationTime", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"options" => {
obj.options = Some(TransitGatewayOptionsDeserializer::deserialize(
"options", stack,
)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"state" => {
obj.state = Some(TransitGatewayStateDeserializer::deserialize(
"state", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"transitGatewayArn" => {
obj.transit_gateway_arn =
Some(StringDeserializer::deserialize("transitGatewayArn", stack)?);
}
"transitGatewayId" => {
obj.transit_gateway_id =
Some(StringDeserializer::deserialize("transitGatewayId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayAssociation {
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub state: Option<String>,
pub transit_gateway_attachment_id: Option<String>,
pub transit_gateway_route_table_id: Option<String>,
}
struct TransitGatewayAssociationDeserializer;
impl TransitGatewayAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayAssociation, XmlParseError> {
deserialize_elements::<_, TransitGatewayAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceId" => {
obj.resource_id =
Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(
TransitGatewayAttachmentResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?,
);
}
"state" => {
obj.state = Some(TransitGatewayAssociationStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
"transitGatewayRouteTableId" => {
obj.transit_gateway_route_table_id = Some(StringDeserializer::deserialize(
"transitGatewayRouteTableId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayAssociationStateDeserializer;
impl TransitGatewayAssociationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayAttachment {
pub association: Option<TransitGatewayAttachmentAssociation>,
pub creation_time: Option<String>,
pub resource_id: Option<String>,
pub resource_owner_id: Option<String>,
pub resource_type: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub transit_gateway_attachment_id: Option<String>,
pub transit_gateway_id: Option<String>,
pub transit_gateway_owner_id: Option<String>,
}
struct TransitGatewayAttachmentDeserializer;
impl TransitGatewayAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayAttachment, XmlParseError> {
deserialize_elements::<_, TransitGatewayAttachment, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"association" => {
obj.association = Some(
TransitGatewayAttachmentAssociationDeserializer::deserialize(
"association",
stack,
)?,
);
}
"creationTime" => {
obj.creation_time =
Some(DateTimeDeserializer::deserialize("creationTime", stack)?);
}
"resourceId" => {
obj.resource_id =
Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceOwnerId" => {
obj.resource_owner_id =
Some(StringDeserializer::deserialize("resourceOwnerId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(
TransitGatewayAttachmentResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?,
);
}
"state" => {
obj.state = Some(TransitGatewayAttachmentStateDeserializer::deserialize(
"state", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
"transitGatewayId" => {
obj.transit_gateway_id =
Some(StringDeserializer::deserialize("transitGatewayId", stack)?);
}
"transitGatewayOwnerId" => {
obj.transit_gateway_owner_id = Some(StringDeserializer::deserialize(
"transitGatewayOwnerId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayAttachmentAssociation {
pub state: Option<String>,
pub transit_gateway_route_table_id: Option<String>,
}
struct TransitGatewayAttachmentAssociationDeserializer;
impl TransitGatewayAttachmentAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayAttachmentAssociation, XmlParseError> {
deserialize_elements::<_, TransitGatewayAttachmentAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"state" => {
obj.state = Some(TransitGatewayAssociationStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayRouteTableId" => {
obj.transit_gateway_route_table_id = Some(StringDeserializer::deserialize(
"transitGatewayRouteTableId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayAttachmentIdStringListSerializer;
impl TransitGatewayAttachmentIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct TransitGatewayAttachmentListDeserializer;
impl TransitGatewayAttachmentListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayAttachment>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TransitGatewayAttachmentDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayAttachmentPropagation {
pub state: Option<String>,
pub transit_gateway_route_table_id: Option<String>,
}
struct TransitGatewayAttachmentPropagationDeserializer;
impl TransitGatewayAttachmentPropagationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayAttachmentPropagation, XmlParseError> {
deserialize_elements::<_, TransitGatewayAttachmentPropagation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"state" => {
obj.state = Some(TransitGatewayPropagationStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayRouteTableId" => {
obj.transit_gateway_route_table_id = Some(StringDeserializer::deserialize(
"transitGatewayRouteTableId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayAttachmentPropagationListDeserializer;
impl TransitGatewayAttachmentPropagationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayAttachmentPropagation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
TransitGatewayAttachmentPropagationDeserializer::deserialize("item", stack)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TransitGatewayAttachmentResourceTypeDeserializer;
impl TransitGatewayAttachmentResourceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TransitGatewayAttachmentStateDeserializer;
impl TransitGatewayAttachmentStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TransitGatewayIdStringListSerializer;
impl TransitGatewayIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct TransitGatewayListDeserializer;
impl TransitGatewayListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGateway>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TransitGatewayDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayOptions {
pub amazon_side_asn: Option<i64>,
pub association_default_route_table_id: Option<String>,
pub auto_accept_shared_attachments: Option<String>,
pub default_route_table_association: Option<String>,
pub default_route_table_propagation: Option<String>,
pub dns_support: Option<String>,
pub propagation_default_route_table_id: Option<String>,
pub vpn_ecmp_support: Option<String>,
}
struct TransitGatewayOptionsDeserializer;
impl TransitGatewayOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayOptions, XmlParseError> {
deserialize_elements::<_, TransitGatewayOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"amazonSideAsn" => {
obj.amazon_side_asn =
Some(LongDeserializer::deserialize("amazonSideAsn", stack)?);
}
"associationDefaultRouteTableId" => {
obj.association_default_route_table_id = Some(StringDeserializer::deserialize(
"associationDefaultRouteTableId",
stack,
)?);
}
"autoAcceptSharedAttachments" => {
obj.auto_accept_shared_attachments =
Some(AutoAcceptSharedAttachmentsValueDeserializer::deserialize(
"autoAcceptSharedAttachments",
stack,
)?);
}
"defaultRouteTableAssociation" => {
obj.default_route_table_association =
Some(DefaultRouteTableAssociationValueDeserializer::deserialize(
"defaultRouteTableAssociation",
stack,
)?);
}
"defaultRouteTablePropagation" => {
obj.default_route_table_propagation =
Some(DefaultRouteTablePropagationValueDeserializer::deserialize(
"defaultRouteTablePropagation",
stack,
)?);
}
"dnsSupport" => {
obj.dns_support = Some(DnsSupportValueDeserializer::deserialize(
"dnsSupport",
stack,
)?);
}
"propagationDefaultRouteTableId" => {
obj.propagation_default_route_table_id = Some(StringDeserializer::deserialize(
"propagationDefaultRouteTableId",
stack,
)?);
}
"vpnEcmpSupport" => {
obj.vpn_ecmp_support = Some(VpnEcmpSupportValueDeserializer::deserialize(
"vpnEcmpSupport",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayPropagation {
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub state: Option<String>,
pub transit_gateway_attachment_id: Option<String>,
pub transit_gateway_route_table_id: Option<String>,
}
struct TransitGatewayPropagationDeserializer;
impl TransitGatewayPropagationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayPropagation, XmlParseError> {
deserialize_elements::<_, TransitGatewayPropagation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceId" => {
obj.resource_id =
Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(
TransitGatewayAttachmentResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?,
);
}
"state" => {
obj.state = Some(TransitGatewayPropagationStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
"transitGatewayRouteTableId" => {
obj.transit_gateway_route_table_id = Some(StringDeserializer::deserialize(
"transitGatewayRouteTableId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayPropagationStateDeserializer;
impl TransitGatewayPropagationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayRequestOptions {
pub amazon_side_asn: Option<i64>,
pub auto_accept_shared_attachments: Option<String>,
pub default_route_table_association: Option<String>,
pub default_route_table_propagation: Option<String>,
pub dns_support: Option<String>,
pub vpn_ecmp_support: Option<String>,
}
struct TransitGatewayRequestOptionsSerializer;
impl TransitGatewayRequestOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TransitGatewayRequestOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.amazon_side_asn {
params.put(&format!("{}{}", prefix, "AmazonSideAsn"), &field_value);
}
if let Some(ref field_value) = obj.auto_accept_shared_attachments {
params.put(
&format!("{}{}", prefix, "AutoAcceptSharedAttachments"),
&field_value,
);
}
if let Some(ref field_value) = obj.default_route_table_association {
params.put(
&format!("{}{}", prefix, "DefaultRouteTableAssociation"),
&field_value,
);
}
if let Some(ref field_value) = obj.default_route_table_propagation {
params.put(
&format!("{}{}", prefix, "DefaultRouteTablePropagation"),
&field_value,
);
}
if let Some(ref field_value) = obj.dns_support {
params.put(&format!("{}{}", prefix, "DnsSupport"), &field_value);
}
if let Some(ref field_value) = obj.vpn_ecmp_support {
params.put(&format!("{}{}", prefix, "VpnEcmpSupport"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayRoute {
pub destination_cidr_block: Option<String>,
pub state: Option<String>,
pub transit_gateway_attachments: Option<Vec<TransitGatewayRouteAttachment>>,
pub type_: Option<String>,
}
struct TransitGatewayRouteDeserializer;
impl TransitGatewayRouteDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayRoute, XmlParseError> {
deserialize_elements::<_, TransitGatewayRoute, _>(tag_name, stack, |name, stack, obj| {
match name {
"destinationCidrBlock" => {
obj.destination_cidr_block = Some(StringDeserializer::deserialize(
"destinationCidrBlock",
stack,
)?);
}
"state" => {
obj.state = Some(TransitGatewayRouteStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayAttachments" => {
obj.transit_gateway_attachments
.get_or_insert(vec![])
.extend(TransitGatewayRouteAttachmentListDeserializer::deserialize(
"transitGatewayAttachments",
stack,
)?);
}
"type" => {
obj.type_ = Some(TransitGatewayRouteTypeDeserializer::deserialize(
"type", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayRouteAttachment {
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub transit_gateway_attachment_id: Option<String>,
}
struct TransitGatewayRouteAttachmentDeserializer;
impl TransitGatewayRouteAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayRouteAttachment, XmlParseError> {
deserialize_elements::<_, TransitGatewayRouteAttachment, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceId" => {
obj.resource_id =
Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(
TransitGatewayAttachmentResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?,
);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayRouteAttachmentListDeserializer;
impl TransitGatewayRouteAttachmentListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayRouteAttachment>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TransitGatewayRouteAttachmentDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TransitGatewayRouteListDeserializer;
impl TransitGatewayRouteListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayRoute>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TransitGatewayRouteDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TransitGatewayRouteStateDeserializer;
impl TransitGatewayRouteStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayRouteTable {
pub creation_time: Option<String>,
pub default_association_route_table: Option<bool>,
pub default_propagation_route_table: Option<bool>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub transit_gateway_id: Option<String>,
pub transit_gateway_route_table_id: Option<String>,
}
struct TransitGatewayRouteTableDeserializer;
impl TransitGatewayRouteTableDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayRouteTable, XmlParseError> {
deserialize_elements::<_, TransitGatewayRouteTable, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"creationTime" => {
obj.creation_time =
Some(DateTimeDeserializer::deserialize("creationTime", stack)?);
}
"defaultAssociationRouteTable" => {
obj.default_association_route_table =
Some(BooleanDeserializer::deserialize(
"defaultAssociationRouteTable",
stack,
)?);
}
"defaultPropagationRouteTable" => {
obj.default_propagation_route_table =
Some(BooleanDeserializer::deserialize(
"defaultPropagationRouteTable",
stack,
)?);
}
"state" => {
obj.state = Some(TransitGatewayRouteTableStateDeserializer::deserialize(
"state", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"transitGatewayId" => {
obj.transit_gateway_id =
Some(StringDeserializer::deserialize("transitGatewayId", stack)?);
}
"transitGatewayRouteTableId" => {
obj.transit_gateway_route_table_id = Some(StringDeserializer::deserialize(
"transitGatewayRouteTableId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayRouteTableAssociation {
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub state: Option<String>,
pub transit_gateway_attachment_id: Option<String>,
}
struct TransitGatewayRouteTableAssociationDeserializer;
impl TransitGatewayRouteTableAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayRouteTableAssociation, XmlParseError> {
deserialize_elements::<_, TransitGatewayRouteTableAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceId" => {
obj.resource_id =
Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(
TransitGatewayAttachmentResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?,
);
}
"state" => {
obj.state = Some(TransitGatewayAssociationStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayRouteTableAssociationListDeserializer;
impl TransitGatewayRouteTableAssociationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayRouteTableAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
TransitGatewayRouteTableAssociationDeserializer::deserialize("item", stack)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TransitGatewayRouteTableIdStringListSerializer;
impl TransitGatewayRouteTableIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct TransitGatewayRouteTableListDeserializer;
impl TransitGatewayRouteTableListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayRouteTable>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TransitGatewayRouteTableDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayRouteTablePropagation {
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub state: Option<String>,
pub transit_gateway_attachment_id: Option<String>,
}
struct TransitGatewayRouteTablePropagationDeserializer;
impl TransitGatewayRouteTablePropagationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayRouteTablePropagation, XmlParseError> {
deserialize_elements::<_, TransitGatewayRouteTablePropagation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"resourceId" => {
obj.resource_id =
Some(StringDeserializer::deserialize("resourceId", stack)?);
}
"resourceType" => {
obj.resource_type = Some(
TransitGatewayAttachmentResourceTypeDeserializer::deserialize(
"resourceType",
stack,
)?,
);
}
"state" => {
obj.state = Some(TransitGatewayPropagationStateDeserializer::deserialize(
"state", stack,
)?);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayRouteTablePropagationListDeserializer;
impl TransitGatewayRouteTablePropagationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayRouteTablePropagation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
TransitGatewayRouteTablePropagationDeserializer::deserialize("item", stack)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TransitGatewayRouteTableStateDeserializer;
impl TransitGatewayRouteTableStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TransitGatewayRouteTypeDeserializer;
impl TransitGatewayRouteTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TransitGatewayStateDeserializer;
impl TransitGatewayStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayVpcAttachment {
pub creation_time: Option<String>,
pub options: Option<TransitGatewayVpcAttachmentOptions>,
pub state: Option<String>,
pub subnet_ids: Option<Vec<String>>,
pub tags: Option<Vec<Tag>>,
pub transit_gateway_attachment_id: Option<String>,
pub transit_gateway_id: Option<String>,
pub vpc_id: Option<String>,
pub vpc_owner_id: Option<String>,
}
struct TransitGatewayVpcAttachmentDeserializer;
impl TransitGatewayVpcAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayVpcAttachment, XmlParseError> {
deserialize_elements::<_, TransitGatewayVpcAttachment, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"creationTime" => {
obj.creation_time =
Some(DateTimeDeserializer::deserialize("creationTime", stack)?);
}
"options" => {
obj.options =
Some(TransitGatewayVpcAttachmentOptionsDeserializer::deserialize(
"options", stack,
)?);
}
"state" => {
obj.state = Some(TransitGatewayAttachmentStateDeserializer::deserialize(
"state", stack,
)?);
}
"subnetIds" => {
obj.subnet_ids.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("subnetIds", stack)?,
);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"transitGatewayAttachmentId" => {
obj.transit_gateway_attachment_id = Some(StringDeserializer::deserialize(
"transitGatewayAttachmentId",
stack,
)?);
}
"transitGatewayId" => {
obj.transit_gateway_id =
Some(StringDeserializer::deserialize("transitGatewayId", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
"vpcOwnerId" => {
obj.vpc_owner_id =
Some(StringDeserializer::deserialize("vpcOwnerId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransitGatewayVpcAttachmentListDeserializer;
impl TransitGatewayVpcAttachmentListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TransitGatewayVpcAttachment>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(TransitGatewayVpcAttachmentDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TransitGatewayVpcAttachmentOptions {
pub dns_support: Option<String>,
pub ipv_6_support: Option<String>,
}
struct TransitGatewayVpcAttachmentOptionsDeserializer;
impl TransitGatewayVpcAttachmentOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TransitGatewayVpcAttachmentOptions, XmlParseError> {
deserialize_elements::<_, TransitGatewayVpcAttachmentOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"dnsSupport" => {
obj.dns_support = Some(DnsSupportValueDeserializer::deserialize(
"dnsSupport",
stack,
)?);
}
"ipv6Support" => {
obj.ipv_6_support = Some(Ipv6SupportValueDeserializer::deserialize(
"ipv6Support",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct TransportProtocolDeserializer;
impl TransportProtocolDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TunnelOptionsListSerializer;
impl TunnelOptionsListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<VpnTunnelOptionsSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
VpnTunnelOptionsSpecificationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnassignIpv6AddressesRequest {
pub ipv_6_addresses: Vec<String>,
pub network_interface_id: String,
}
struct UnassignIpv6AddressesRequestSerializer;
impl UnassignIpv6AddressesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UnassignIpv6AddressesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
Ipv6AddressListSerializer::serialize(
params,
&format!("{}{}", prefix, "Ipv6Addresses"),
&obj.ipv_6_addresses,
);
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnassignIpv6AddressesResult {
pub network_interface_id: Option<String>,
pub unassigned_ipv_6_addresses: Option<Vec<String>>,
}
struct UnassignIpv6AddressesResultDeserializer;
impl UnassignIpv6AddressesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnassignIpv6AddressesResult, XmlParseError> {
deserialize_elements::<_, UnassignIpv6AddressesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"networkInterfaceId" => {
obj.network_interface_id = Some(StringDeserializer::deserialize(
"networkInterfaceId",
stack,
)?);
}
"unassignedIpv6Addresses" => {
obj.unassigned_ipv_6_addresses.get_or_insert(vec![]).extend(
Ipv6AddressListDeserializer::deserialize(
"unassignedIpv6Addresses",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnassignPrivateIpAddressesRequest {
pub network_interface_id: String,
pub private_ip_addresses: Vec<String>,
}
struct UnassignPrivateIpAddressesRequestSerializer;
impl UnassignPrivateIpAddressesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UnassignPrivateIpAddressesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "NetworkInterfaceId"),
&obj.network_interface_id,
);
PrivateIpAddressStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "PrivateIpAddress"),
&obj.private_ip_addresses,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnmonitorInstancesRequest {
pub dry_run: Option<bool>,
pub instance_ids: Vec<String>,
}
struct UnmonitorInstancesRequestSerializer;
impl UnmonitorInstancesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UnmonitorInstancesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
InstanceIdStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceId"),
&obj.instance_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnmonitorInstancesResult {
pub instance_monitorings: Option<Vec<InstanceMonitoring>>,
}
struct UnmonitorInstancesResultDeserializer;
impl UnmonitorInstancesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnmonitorInstancesResult, XmlParseError> {
deserialize_elements::<_, UnmonitorInstancesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"instancesSet" => {
obj.instance_monitorings.get_or_insert(vec![]).extend(
InstanceMonitoringListDeserializer::deserialize("instancesSet", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct UnsuccessfulInstanceCreditSpecificationErrorCodeDeserializer;
impl UnsuccessfulInstanceCreditSpecificationErrorCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnsuccessfulInstanceCreditSpecificationItem {
pub error: Option<UnsuccessfulInstanceCreditSpecificationItemError>,
pub instance_id: Option<String>,
}
struct UnsuccessfulInstanceCreditSpecificationItemDeserializer;
impl UnsuccessfulInstanceCreditSpecificationItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnsuccessfulInstanceCreditSpecificationItem, XmlParseError> {
deserialize_elements::<_, UnsuccessfulInstanceCreditSpecificationItem, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"error" => {
obj.error = Some(UnsuccessfulInstanceCreditSpecificationItemErrorDeserializer::deserialize("error", stack)?);
}
"instanceId" => {
obj.instance_id =
Some(StringDeserializer::deserialize("instanceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnsuccessfulInstanceCreditSpecificationItemError {
pub code: Option<String>,
pub message: Option<String>,
}
struct UnsuccessfulInstanceCreditSpecificationItemErrorDeserializer;
impl UnsuccessfulInstanceCreditSpecificationItemErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnsuccessfulInstanceCreditSpecificationItemError, XmlParseError> {
deserialize_elements::<_, UnsuccessfulInstanceCreditSpecificationItemError, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(UnsuccessfulInstanceCreditSpecificationErrorCodeDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct UnsuccessfulInstanceCreditSpecificationSetDeserializer;
impl UnsuccessfulInstanceCreditSpecificationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UnsuccessfulInstanceCreditSpecificationItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(
UnsuccessfulInstanceCreditSpecificationItemDeserializer::deserialize(
"item", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnsuccessfulItem {
pub error: Option<UnsuccessfulItemError>,
pub resource_id: Option<String>,
}
struct UnsuccessfulItemDeserializer;
impl UnsuccessfulItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnsuccessfulItem, XmlParseError> {
deserialize_elements::<_, UnsuccessfulItem, _>(tag_name, stack, |name, stack, obj| {
match name {
"error" => {
obj.error = Some(UnsuccessfulItemErrorDeserializer::deserialize(
"error", stack,
)?);
}
"resourceId" => {
obj.resource_id = Some(StringDeserializer::deserialize("resourceId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UnsuccessfulItemError {
pub code: Option<String>,
pub message: Option<String>,
}
struct UnsuccessfulItemErrorDeserializer;
impl UnsuccessfulItemErrorDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnsuccessfulItemError, XmlParseError> {
deserialize_elements::<_, UnsuccessfulItemError, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(StringDeserializer::deserialize("code", stack)?);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct UnsuccessfulItemListDeserializer;
impl UnsuccessfulItemListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UnsuccessfulItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(UnsuccessfulItemDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct UnsuccessfulItemSetDeserializer;
impl UnsuccessfulItemSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UnsuccessfulItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(UnsuccessfulItemDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateSecurityGroupRuleDescriptionsEgressRequest {
pub dry_run: Option<bool>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub ip_permissions: Vec<IpPermission>,
}
struct UpdateSecurityGroupRuleDescriptionsEgressRequestSerializer;
impl UpdateSecurityGroupRuleDescriptionsEgressRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &UpdateSecurityGroupRuleDescriptionsEgressRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
IpPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpPermissions"),
&obj.ip_permissions,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateSecurityGroupRuleDescriptionsEgressResult {
pub return_: Option<bool>,
}
struct UpdateSecurityGroupRuleDescriptionsEgressResultDeserializer;
impl UpdateSecurityGroupRuleDescriptionsEgressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateSecurityGroupRuleDescriptionsEgressResult, XmlParseError> {
deserialize_elements::<_, UpdateSecurityGroupRuleDescriptionsEgressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateSecurityGroupRuleDescriptionsIngressRequest {
pub dry_run: Option<bool>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub ip_permissions: Vec<IpPermission>,
}
struct UpdateSecurityGroupRuleDescriptionsIngressRequestSerializer;
impl UpdateSecurityGroupRuleDescriptionsIngressRequestSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &UpdateSecurityGroupRuleDescriptionsIngressRequest,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
IpPermissionListSerializer::serialize(
params,
&format!("{}{}", prefix, "IpPermissions"),
&obj.ip_permissions,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateSecurityGroupRuleDescriptionsIngressResult {
pub return_: Option<bool>,
}
struct UpdateSecurityGroupRuleDescriptionsIngressResultDeserializer;
impl UpdateSecurityGroupRuleDescriptionsIngressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateSecurityGroupRuleDescriptionsIngressResult, XmlParseError> {
deserialize_elements::<_, UpdateSecurityGroupRuleDescriptionsIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"return" => {
obj.return_ = Some(BooleanDeserializer::deserialize("return", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UserBucket {
pub s3_bucket: Option<String>,
pub s3_key: Option<String>,
}
struct UserBucketSerializer;
impl UserBucketSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UserBucket) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.s3_bucket {
params.put(&format!("{}{}", prefix, "S3Bucket"), &field_value);
}
if let Some(ref field_value) = obj.s3_key {
params.put(&format!("{}{}", prefix, "S3Key"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UserBucketDetails {
pub s3_bucket: Option<String>,
pub s3_key: Option<String>,
}
struct UserBucketDetailsDeserializer;
impl UserBucketDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UserBucketDetails, XmlParseError> {
deserialize_elements::<_, UserBucketDetails, _>(tag_name, stack, |name, stack, obj| {
match name {
"s3Bucket" => {
obj.s3_bucket = Some(StringDeserializer::deserialize("s3Bucket", stack)?);
}
"s3Key" => {
obj.s3_key = Some(StringDeserializer::deserialize("s3Key", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UserData {
pub data: Option<String>,
}
struct UserDataSerializer;
impl UserDataSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UserData) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.data {
params.put(&format!("{}{}", prefix, "Data"), &field_value);
}
}
}
struct UserGroupStringListSerializer;
impl UserGroupStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UserIdGroupPair {
pub description: Option<String>,
pub group_id: Option<String>,
pub group_name: Option<String>,
pub peering_status: Option<String>,
pub user_id: Option<String>,
pub vpc_id: Option<String>,
pub vpc_peering_connection_id: Option<String>,
}
struct UserIdGroupPairDeserializer;
impl UserIdGroupPairDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UserIdGroupPair, XmlParseError> {
deserialize_elements::<_, UserIdGroupPair, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"groupId" => {
obj.group_id = Some(StringDeserializer::deserialize("groupId", stack)?);
}
"groupName" => {
obj.group_name = Some(StringDeserializer::deserialize("groupName", stack)?);
}
"peeringStatus" => {
obj.peering_status =
Some(StringDeserializer::deserialize("peeringStatus", stack)?);
}
"userId" => {
obj.user_id = Some(StringDeserializer::deserialize("userId", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
"vpcPeeringConnectionId" => {
obj.vpc_peering_connection_id = Some(StringDeserializer::deserialize(
"vpcPeeringConnectionId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct UserIdGroupPairSerializer;
impl UserIdGroupPairSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UserIdGroupPair) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.group_id {
params.put(&format!("{}{}", prefix, "GroupId"), &field_value);
}
if let Some(ref field_value) = obj.group_name {
params.put(&format!("{}{}", prefix, "GroupName"), &field_value);
}
if let Some(ref field_value) = obj.peering_status {
params.put(&format!("{}{}", prefix, "PeeringStatus"), &field_value);
}
if let Some(ref field_value) = obj.user_id {
params.put(&format!("{}{}", prefix, "UserId"), &field_value);
}
if let Some(ref field_value) = obj.vpc_id {
params.put(&format!("{}{}", prefix, "VpcId"), &field_value);
}
if let Some(ref field_value) = obj.vpc_peering_connection_id {
params.put(
&format!("{}{}", prefix, "VpcPeeringConnectionId"),
&field_value,
);
}
}
}
struct UserIdGroupPairListDeserializer;
impl UserIdGroupPairListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UserIdGroupPair>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(UserIdGroupPairDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct UserIdGroupPairListSerializer;
impl UserIdGroupPairListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<UserIdGroupPair>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
UserIdGroupPairSerializer::serialize(params, &key, obj);
}
}
}
struct UserIdGroupPairSetDeserializer;
impl UserIdGroupPairSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UserIdGroupPair>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(UserIdGroupPairDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct UserIdStringListSerializer;
impl UserIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ValueStringListDeserializer;
impl ValueStringListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(StringDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ValueStringListSerializer;
impl ValueStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct VersionDescriptionDeserializer;
impl VersionDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct VersionStringListSerializer;
impl VersionStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VgwTelemetry {
pub accepted_route_count: Option<i64>,
pub last_status_change: Option<String>,
pub outside_ip_address: Option<String>,
pub status: Option<String>,
pub status_message: Option<String>,
}
struct VgwTelemetryDeserializer;
impl VgwTelemetryDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VgwTelemetry, XmlParseError> {
deserialize_elements::<_, VgwTelemetry, _>(tag_name, stack, |name, stack, obj| {
match name {
"acceptedRouteCount" => {
obj.accepted_route_count = Some(IntegerDeserializer::deserialize(
"acceptedRouteCount",
stack,
)?);
}
"lastStatusChange" => {
obj.last_status_change = Some(DateTimeDeserializer::deserialize(
"lastStatusChange",
stack,
)?);
}
"outsideIpAddress" => {
obj.outside_ip_address =
Some(StringDeserializer::deserialize("outsideIpAddress", stack)?);
}
"status" => {
obj.status = Some(TelemetryStatusDeserializer::deserialize("status", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VgwTelemetryListDeserializer;
impl VgwTelemetryListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VgwTelemetry>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VgwTelemetryDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VirtualizationTypeDeserializer;
impl VirtualizationTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Volume {
pub attachments: Option<Vec<VolumeAttachment>>,
pub availability_zone: Option<String>,
pub create_time: Option<String>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub size: Option<i64>,
pub snapshot_id: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub volume_id: Option<String>,
pub volume_type: Option<String>,
}
struct VolumeDeserializer;
impl VolumeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Volume, XmlParseError> {
deserialize_elements::<_, Volume, _>(tag_name, stack, |name, stack, obj| {
match name {
"attachmentSet" => {
obj.attachments.get_or_insert(vec![]).extend(
VolumeAttachmentListDeserializer::deserialize("attachmentSet", stack)?,
);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"createTime" => {
obj.create_time = Some(DateTimeDeserializer::deserialize("createTime", stack)?);
}
"encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("encrypted", stack)?);
}
"iops" => {
obj.iops = Some(IntegerDeserializer::deserialize("iops", stack)?);
}
"kmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("kmsKeyId", stack)?);
}
"size" => {
obj.size = Some(IntegerDeserializer::deserialize("size", stack)?);
}
"snapshotId" => {
obj.snapshot_id = Some(StringDeserializer::deserialize("snapshotId", stack)?);
}
"status" => {
obj.state = Some(VolumeStateDeserializer::deserialize("status", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
"volumeType" => {
obj.volume_type =
Some(VolumeTypeDeserializer::deserialize("volumeType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeAttachment {
pub attach_time: Option<String>,
pub delete_on_termination: Option<bool>,
pub device: Option<String>,
pub instance_id: Option<String>,
pub state: Option<String>,
pub volume_id: Option<String>,
}
struct VolumeAttachmentDeserializer;
impl VolumeAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeAttachment, XmlParseError> {
deserialize_elements::<_, VolumeAttachment, _>(tag_name, stack, |name, stack, obj| {
match name {
"attachTime" => {
obj.attach_time = Some(DateTimeDeserializer::deserialize("attachTime", stack)?);
}
"deleteOnTermination" => {
obj.delete_on_termination = Some(BooleanDeserializer::deserialize(
"deleteOnTermination",
stack,
)?);
}
"device" => {
obj.device = Some(StringDeserializer::deserialize("device", stack)?);
}
"instanceId" => {
obj.instance_id = Some(StringDeserializer::deserialize("instanceId", stack)?);
}
"status" => {
obj.state = Some(VolumeAttachmentStateDeserializer::deserialize(
"status", stack,
)?);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeAttachmentListDeserializer;
impl VolumeAttachmentListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VolumeAttachment>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeAttachmentDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VolumeAttachmentStateDeserializer;
impl VolumeAttachmentStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeDetail {
pub size: i64,
}
struct VolumeDetailSerializer;
impl VolumeDetailSerializer {
fn serialize(params: &mut Params, name: &str, obj: &VolumeDetail) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Size"), &obj.size);
}
}
struct VolumeIdStringListSerializer;
impl VolumeIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct VolumeListDeserializer;
impl VolumeListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Volume>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeModification {
pub end_time: Option<String>,
pub modification_state: Option<String>,
pub original_iops: Option<i64>,
pub original_size: Option<i64>,
pub original_volume_type: Option<String>,
pub progress: Option<i64>,
pub start_time: Option<String>,
pub status_message: Option<String>,
pub target_iops: Option<i64>,
pub target_size: Option<i64>,
pub target_volume_type: Option<String>,
pub volume_id: Option<String>,
}
struct VolumeModificationDeserializer;
impl VolumeModificationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeModification, XmlParseError> {
deserialize_elements::<_, VolumeModification, _>(tag_name, stack, |name, stack, obj| {
match name {
"endTime" => {
obj.end_time = Some(DateTimeDeserializer::deserialize("endTime", stack)?);
}
"modificationState" => {
obj.modification_state =
Some(VolumeModificationStateDeserializer::deserialize(
"modificationState",
stack,
)?);
}
"originalIops" => {
obj.original_iops =
Some(IntegerDeserializer::deserialize("originalIops", stack)?);
}
"originalSize" => {
obj.original_size =
Some(IntegerDeserializer::deserialize("originalSize", stack)?);
}
"originalVolumeType" => {
obj.original_volume_type = Some(VolumeTypeDeserializer::deserialize(
"originalVolumeType",
stack,
)?);
}
"progress" => {
obj.progress = Some(LongDeserializer::deserialize("progress", stack)?);
}
"startTime" => {
obj.start_time = Some(DateTimeDeserializer::deserialize("startTime", stack)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
"targetIops" => {
obj.target_iops = Some(IntegerDeserializer::deserialize("targetIops", stack)?);
}
"targetSize" => {
obj.target_size = Some(IntegerDeserializer::deserialize("targetSize", stack)?);
}
"targetVolumeType" => {
obj.target_volume_type = Some(VolumeTypeDeserializer::deserialize(
"targetVolumeType",
stack,
)?);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeModificationListDeserializer;
impl VolumeModificationListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VolumeModification>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeModificationDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VolumeModificationStateDeserializer;
impl VolumeModificationStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct VolumeStateDeserializer;
impl VolumeStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeStatusAction {
pub code: Option<String>,
pub description: Option<String>,
pub event_id: Option<String>,
pub event_type: Option<String>,
}
struct VolumeStatusActionDeserializer;
impl VolumeStatusActionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeStatusAction, XmlParseError> {
deserialize_elements::<_, VolumeStatusAction, _>(tag_name, stack, |name, stack, obj| {
match name {
"code" => {
obj.code = Some(StringDeserializer::deserialize("code", stack)?);
}
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"eventId" => {
obj.event_id = Some(StringDeserializer::deserialize("eventId", stack)?);
}
"eventType" => {
obj.event_type = Some(StringDeserializer::deserialize("eventType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeStatusActionsListDeserializer;
impl VolumeStatusActionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VolumeStatusAction>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeStatusActionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeStatusDetails {
pub name: Option<String>,
pub status: Option<String>,
}
struct VolumeStatusDetailsDeserializer;
impl VolumeStatusDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeStatusDetails, XmlParseError> {
deserialize_elements::<_, VolumeStatusDetails, _>(tag_name, stack, |name, stack, obj| {
match name {
"name" => {
obj.name = Some(VolumeStatusNameDeserializer::deserialize("name", stack)?);
}
"status" => {
obj.status = Some(StringDeserializer::deserialize("status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeStatusDetailsListDeserializer;
impl VolumeStatusDetailsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VolumeStatusDetails>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeStatusDetailsDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeStatusEvent {
pub description: Option<String>,
pub event_id: Option<String>,
pub event_type: Option<String>,
pub not_after: Option<String>,
pub not_before: Option<String>,
}
struct VolumeStatusEventDeserializer;
impl VolumeStatusEventDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeStatusEvent, XmlParseError> {
deserialize_elements::<_, VolumeStatusEvent, _>(tag_name, stack, |name, stack, obj| {
match name {
"description" => {
obj.description = Some(StringDeserializer::deserialize("description", stack)?);
}
"eventId" => {
obj.event_id = Some(StringDeserializer::deserialize("eventId", stack)?);
}
"eventType" => {
obj.event_type = Some(StringDeserializer::deserialize("eventType", stack)?);
}
"notAfter" => {
obj.not_after = Some(DateTimeDeserializer::deserialize("notAfter", stack)?);
}
"notBefore" => {
obj.not_before = Some(DateTimeDeserializer::deserialize("notBefore", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeStatusEventsListDeserializer;
impl VolumeStatusEventsListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VolumeStatusEvent>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeStatusEventDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeStatusInfo {
pub details: Option<Vec<VolumeStatusDetails>>,
pub status: Option<String>,
}
struct VolumeStatusInfoDeserializer;
impl VolumeStatusInfoDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeStatusInfo, XmlParseError> {
deserialize_elements::<_, VolumeStatusInfo, _>(tag_name, stack, |name, stack, obj| {
match name {
"details" => {
obj.details.get_or_insert(vec![]).extend(
VolumeStatusDetailsListDeserializer::deserialize("details", stack)?,
);
}
"status" => {
obj.status = Some(VolumeStatusInfoStatusDeserializer::deserialize(
"status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeStatusInfoStatusDeserializer;
impl VolumeStatusInfoStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VolumeStatusItem {
pub actions: Option<Vec<VolumeStatusAction>>,
pub availability_zone: Option<String>,
pub events: Option<Vec<VolumeStatusEvent>>,
pub volume_id: Option<String>,
pub volume_status: Option<VolumeStatusInfo>,
}
struct VolumeStatusItemDeserializer;
impl VolumeStatusItemDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VolumeStatusItem, XmlParseError> {
deserialize_elements::<_, VolumeStatusItem, _>(tag_name, stack, |name, stack, obj| {
match name {
"actionsSet" => {
obj.actions.get_or_insert(vec![]).extend(
VolumeStatusActionsListDeserializer::deserialize("actionsSet", stack)?,
);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"eventsSet" => {
obj.events.get_or_insert(vec![]).extend(
VolumeStatusEventsListDeserializer::deserialize("eventsSet", stack)?,
);
}
"volumeId" => {
obj.volume_id = Some(StringDeserializer::deserialize("volumeId", stack)?);
}
"volumeStatus" => {
obj.volume_status = Some(VolumeStatusInfoDeserializer::deserialize(
"volumeStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VolumeStatusListDeserializer;
impl VolumeStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VolumeStatusItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VolumeStatusItemDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VolumeStatusNameDeserializer;
impl VolumeStatusNameDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct VolumeTypeDeserializer;
impl VolumeTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Vpc {
pub cidr_block: Option<String>,
pub cidr_block_association_set: Option<Vec<VpcCidrBlockAssociation>>,
pub dhcp_options_id: Option<String>,
pub instance_tenancy: Option<String>,
pub ipv_6_cidr_block_association_set: Option<Vec<VpcIpv6CidrBlockAssociation>>,
pub is_default: Option<bool>,
pub owner_id: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct VpcDeserializer;
impl VpcDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Vpc, XmlParseError> {
deserialize_elements::<_, Vpc, _>(tag_name, stack, |name, stack, obj| {
match name {
"cidrBlock" => {
obj.cidr_block = Some(StringDeserializer::deserialize("cidrBlock", stack)?);
}
"cidrBlockAssociationSet" => {
obj.cidr_block_association_set.get_or_insert(vec![]).extend(
VpcCidrBlockAssociationSetDeserializer::deserialize(
"cidrBlockAssociationSet",
stack,
)?,
);
}
"dhcpOptionsId" => {
obj.dhcp_options_id =
Some(StringDeserializer::deserialize("dhcpOptionsId", stack)?);
}
"instanceTenancy" => {
obj.instance_tenancy =
Some(TenancyDeserializer::deserialize("instanceTenancy", stack)?);
}
"ipv6CidrBlockAssociationSet" => {
obj.ipv_6_cidr_block_association_set
.get_or_insert(vec![])
.extend(VpcIpv6CidrBlockAssociationSetDeserializer::deserialize(
"ipv6CidrBlockAssociationSet",
stack,
)?);
}
"isDefault" => {
obj.is_default = Some(BooleanDeserializer::deserialize("isDefault", stack)?);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"state" => {
obj.state = Some(VpcStateDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcAttachment {
pub state: Option<String>,
pub vpc_id: Option<String>,
}
struct VpcAttachmentDeserializer;
impl VpcAttachmentDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcAttachment, XmlParseError> {
deserialize_elements::<_, VpcAttachment, _>(tag_name, stack, |name, stack, obj| {
match name {
"state" => {
obj.state = Some(AttachmentStatusDeserializer::deserialize("state", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpcAttachmentListDeserializer;
impl VpcAttachmentListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcAttachment>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcAttachmentDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcCidrBlockAssociation {
pub association_id: Option<String>,
pub cidr_block: Option<String>,
pub cidr_block_state: Option<VpcCidrBlockState>,
}
struct VpcCidrBlockAssociationDeserializer;
impl VpcCidrBlockAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcCidrBlockAssociation, XmlParseError> {
deserialize_elements::<_, VpcCidrBlockAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"cidrBlock" => {
obj.cidr_block = Some(StringDeserializer::deserialize("cidrBlock", stack)?);
}
"cidrBlockState" => {
obj.cidr_block_state = Some(VpcCidrBlockStateDeserializer::deserialize(
"cidrBlockState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct VpcCidrBlockAssociationSetDeserializer;
impl VpcCidrBlockAssociationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcCidrBlockAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcCidrBlockAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcCidrBlockState {
pub state: Option<String>,
pub status_message: Option<String>,
}
struct VpcCidrBlockStateDeserializer;
impl VpcCidrBlockStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcCidrBlockState, XmlParseError> {
deserialize_elements::<_, VpcCidrBlockState, _>(tag_name, stack, |name, stack, obj| {
match name {
"state" => {
obj.state = Some(VpcCidrBlockStateCodeDeserializer::deserialize(
"state", stack,
)?);
}
"statusMessage" => {
obj.status_message =
Some(StringDeserializer::deserialize("statusMessage", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpcCidrBlockStateCodeDeserializer;
impl VpcCidrBlockStateCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcClassicLink {
pub classic_link_enabled: Option<bool>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
struct VpcClassicLinkDeserializer;
impl VpcClassicLinkDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcClassicLink, XmlParseError> {
deserialize_elements::<_, VpcClassicLink, _>(tag_name, stack, |name, stack, obj| {
match name {
"classicLinkEnabled" => {
obj.classic_link_enabled = Some(BooleanDeserializer::deserialize(
"classicLinkEnabled",
stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpcClassicLinkIdListSerializer;
impl VpcClassicLinkIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct VpcClassicLinkListDeserializer;
impl VpcClassicLinkListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcClassicLink>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcClassicLinkDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcEndpoint {
pub creation_timestamp: Option<String>,
pub dns_entries: Option<Vec<DnsEntry>>,
pub groups: Option<Vec<SecurityGroupIdentifier>>,
pub network_interface_ids: Option<Vec<String>>,
pub policy_document: Option<String>,
pub private_dns_enabled: Option<bool>,
pub requester_managed: Option<bool>,
pub route_table_ids: Option<Vec<String>>,
pub service_name: Option<String>,
pub state: Option<String>,
pub subnet_ids: Option<Vec<String>>,
pub tags: Option<Vec<Tag>>,
pub vpc_endpoint_id: Option<String>,
pub vpc_endpoint_type: Option<String>,
pub vpc_id: Option<String>,
}
struct VpcEndpointDeserializer;
impl VpcEndpointDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcEndpoint, XmlParseError> {
deserialize_elements::<_, VpcEndpoint, _>(tag_name, stack, |name, stack, obj| {
match name {
"creationTimestamp" => {
obj.creation_timestamp = Some(MillisecondDateTimeDeserializer::deserialize(
"creationTimestamp",
stack,
)?);
}
"dnsEntrySet" => {
obj.dns_entries
.get_or_insert(vec![])
.extend(DnsEntrySetDeserializer::deserialize("dnsEntrySet", stack)?);
}
"groupSet" => {
obj.groups.get_or_insert(vec![]).extend(
GroupIdentifierSetDeserializer::deserialize("groupSet", stack)?,
);
}
"networkInterfaceIdSet" => {
obj.network_interface_ids.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("networkInterfaceIdSet", stack)?,
);
}
"policyDocument" => {
obj.policy_document =
Some(StringDeserializer::deserialize("policyDocument", stack)?);
}
"privateDnsEnabled" => {
obj.private_dns_enabled = Some(BooleanDeserializer::deserialize(
"privateDnsEnabled",
stack,
)?);
}
"requesterManaged" => {
obj.requester_managed =
Some(BooleanDeserializer::deserialize("requesterManaged", stack)?);
}
"routeTableIdSet" => {
obj.route_table_ids.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("routeTableIdSet", stack)?,
);
}
"serviceName" => {
obj.service_name = Some(StringDeserializer::deserialize("serviceName", stack)?);
}
"state" => {
obj.state = Some(StateDeserializer::deserialize("state", stack)?);
}
"subnetIdSet" => {
obj.subnet_ids.get_or_insert(vec![]).extend(
ValueStringListDeserializer::deserialize("subnetIdSet", stack)?,
);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcEndpointId" => {
obj.vpc_endpoint_id =
Some(StringDeserializer::deserialize("vpcEndpointId", stack)?);
}
"vpcEndpointType" => {
obj.vpc_endpoint_type = Some(VpcEndpointTypeDeserializer::deserialize(
"vpcEndpointType",
stack,
)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcEndpointConnection {
pub creation_timestamp: Option<String>,
pub service_id: Option<String>,
pub vpc_endpoint_id: Option<String>,
pub vpc_endpoint_owner: Option<String>,
pub vpc_endpoint_state: Option<String>,
}
struct VpcEndpointConnectionDeserializer;
impl VpcEndpointConnectionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcEndpointConnection, XmlParseError> {
deserialize_elements::<_, VpcEndpointConnection, _>(tag_name, stack, |name, stack, obj| {
match name {
"creationTimestamp" => {
obj.creation_timestamp = Some(MillisecondDateTimeDeserializer::deserialize(
"creationTimestamp",
stack,
)?);
}
"serviceId" => {
obj.service_id = Some(StringDeserializer::deserialize("serviceId", stack)?);
}
"vpcEndpointId" => {
obj.vpc_endpoint_id =
Some(StringDeserializer::deserialize("vpcEndpointId", stack)?);
}
"vpcEndpointOwner" => {
obj.vpc_endpoint_owner =
Some(StringDeserializer::deserialize("vpcEndpointOwner", stack)?);
}
"vpcEndpointState" => {
obj.vpc_endpoint_state =
Some(StateDeserializer::deserialize("vpcEndpointState", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpcEndpointConnectionSetDeserializer;
impl VpcEndpointConnectionSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcEndpointConnection>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcEndpointConnectionDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VpcEndpointSetDeserializer;
impl VpcEndpointSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcEndpoint>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcEndpointDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VpcEndpointTypeDeserializer;
impl VpcEndpointTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct VpcIdStringListSerializer;
impl VpcIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcIpv6CidrBlockAssociation {
pub association_id: Option<String>,
pub ipv_6_cidr_block: Option<String>,
pub ipv_6_cidr_block_state: Option<VpcCidrBlockState>,
}
struct VpcIpv6CidrBlockAssociationDeserializer;
impl VpcIpv6CidrBlockAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcIpv6CidrBlockAssociation, XmlParseError> {
deserialize_elements::<_, VpcIpv6CidrBlockAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"associationId" => {
obj.association_id =
Some(StringDeserializer::deserialize("associationId", stack)?);
}
"ipv6CidrBlock" => {
obj.ipv_6_cidr_block =
Some(StringDeserializer::deserialize("ipv6CidrBlock", stack)?);
}
"ipv6CidrBlockState" => {
obj.ipv_6_cidr_block_state =
Some(VpcCidrBlockStateDeserializer::deserialize(
"ipv6CidrBlockState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct VpcIpv6CidrBlockAssociationSetDeserializer;
impl VpcIpv6CidrBlockAssociationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcIpv6CidrBlockAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcIpv6CidrBlockAssociationDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VpcListDeserializer;
impl VpcListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Vpc>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcPeeringConnection {
pub accepter_vpc_info: Option<VpcPeeringConnectionVpcInfo>,
pub expiration_time: Option<String>,
pub requester_vpc_info: Option<VpcPeeringConnectionVpcInfo>,
pub status: Option<VpcPeeringConnectionStateReason>,
pub tags: Option<Vec<Tag>>,
pub vpc_peering_connection_id: Option<String>,
}
struct VpcPeeringConnectionDeserializer;
impl VpcPeeringConnectionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcPeeringConnection, XmlParseError> {
deserialize_elements::<_, VpcPeeringConnection, _>(tag_name, stack, |name, stack, obj| {
match name {
"accepterVpcInfo" => {
obj.accepter_vpc_info =
Some(VpcPeeringConnectionVpcInfoDeserializer::deserialize(
"accepterVpcInfo",
stack,
)?);
}
"expirationTime" => {
obj.expiration_time =
Some(DateTimeDeserializer::deserialize("expirationTime", stack)?);
}
"requesterVpcInfo" => {
obj.requester_vpc_info =
Some(VpcPeeringConnectionVpcInfoDeserializer::deserialize(
"requesterVpcInfo",
stack,
)?);
}
"status" => {
obj.status = Some(VpcPeeringConnectionStateReasonDeserializer::deserialize(
"status", stack,
)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"vpcPeeringConnectionId" => {
obj.vpc_peering_connection_id = Some(StringDeserializer::deserialize(
"vpcPeeringConnectionId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpcPeeringConnectionListDeserializer;
impl VpcPeeringConnectionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcPeeringConnection>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpcPeeringConnectionDeserializer::deserialize(
"item", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcPeeringConnectionOptionsDescription {
pub allow_dns_resolution_from_remote_vpc: Option<bool>,
pub allow_egress_from_local_classic_link_to_remote_vpc: Option<bool>,
pub allow_egress_from_local_vpc_to_remote_classic_link: Option<bool>,
}
struct VpcPeeringConnectionOptionsDescriptionDeserializer;
impl VpcPeeringConnectionOptionsDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcPeeringConnectionOptionsDescription, XmlParseError> {
deserialize_elements::<_, VpcPeeringConnectionOptionsDescription, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"allowDnsResolutionFromRemoteVpc" => {
obj.allow_dns_resolution_from_remote_vpc =
Some(BooleanDeserializer::deserialize(
"allowDnsResolutionFromRemoteVpc",
stack,
)?);
}
"allowEgressFromLocalClassicLinkToRemoteVpc" => {
obj.allow_egress_from_local_classic_link_to_remote_vpc =
Some(BooleanDeserializer::deserialize(
"allowEgressFromLocalClassicLinkToRemoteVpc",
stack,
)?);
}
"allowEgressFromLocalVpcToRemoteClassicLink" => {
obj.allow_egress_from_local_vpc_to_remote_classic_link =
Some(BooleanDeserializer::deserialize(
"allowEgressFromLocalVpcToRemoteClassicLink",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcPeeringConnectionStateReason {
pub code: Option<String>,
pub message: Option<String>,
}
struct VpcPeeringConnectionStateReasonDeserializer;
impl VpcPeeringConnectionStateReasonDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcPeeringConnectionStateReason, XmlParseError> {
deserialize_elements::<_, VpcPeeringConnectionStateReason, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"code" => {
obj.code = Some(
VpcPeeringConnectionStateReasonCodeDeserializer::deserialize(
"code", stack,
)?,
);
}
"message" => {
obj.message = Some(StringDeserializer::deserialize("message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct VpcPeeringConnectionStateReasonCodeDeserializer;
impl VpcPeeringConnectionStateReasonCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpcPeeringConnectionVpcInfo {
pub cidr_block: Option<String>,
pub cidr_block_set: Option<Vec<CidrBlock>>,
pub ipv_6_cidr_block_set: Option<Vec<Ipv6CidrBlock>>,
pub owner_id: Option<String>,
pub peering_options: Option<VpcPeeringConnectionOptionsDescription>,
pub region: Option<String>,
pub vpc_id: Option<String>,
}
struct VpcPeeringConnectionVpcInfoDeserializer;
impl VpcPeeringConnectionVpcInfoDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcPeeringConnectionVpcInfo, XmlParseError> {
deserialize_elements::<_, VpcPeeringConnectionVpcInfo, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"cidrBlock" => {
obj.cidr_block = Some(StringDeserializer::deserialize("cidrBlock", stack)?);
}
"cidrBlockSet" => {
obj.cidr_block_set.get_or_insert(vec![]).extend(
CidrBlockSetDeserializer::deserialize("cidrBlockSet", stack)?,
);
}
"ipv6CidrBlockSet" => {
obj.ipv_6_cidr_block_set.get_or_insert(vec![]).extend(
Ipv6CidrBlockSetDeserializer::deserialize("ipv6CidrBlockSet", stack)?,
);
}
"ownerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("ownerId", stack)?);
}
"peeringOptions" => {
obj.peering_options = Some(
VpcPeeringConnectionOptionsDescriptionDeserializer::deserialize(
"peeringOptions",
stack,
)?,
);
}
"region" => {
obj.region = Some(StringDeserializer::deserialize("region", stack)?);
}
"vpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("vpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct VpcStateDeserializer;
impl VpcStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpnConnection {
pub category: Option<String>,
pub customer_gateway_configuration: Option<String>,
pub customer_gateway_id: Option<String>,
pub options: Option<VpnConnectionOptions>,
pub routes: Option<Vec<VpnStaticRoute>>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub transit_gateway_id: Option<String>,
pub type_: Option<String>,
pub vgw_telemetry: Option<Vec<VgwTelemetry>>,
pub vpn_connection_id: Option<String>,
pub vpn_gateway_id: Option<String>,
}
struct VpnConnectionDeserializer;
impl VpnConnectionDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpnConnection, XmlParseError> {
deserialize_elements::<_, VpnConnection, _>(tag_name, stack, |name, stack, obj| {
match name {
"category" => {
obj.category = Some(StringDeserializer::deserialize("category", stack)?);
}
"customerGatewayConfiguration" => {
obj.customer_gateway_configuration = Some(StringDeserializer::deserialize(
"customerGatewayConfiguration",
stack,
)?);
}
"customerGatewayId" => {
obj.customer_gateway_id =
Some(StringDeserializer::deserialize("customerGatewayId", stack)?);
}
"options" => {
obj.options = Some(VpnConnectionOptionsDeserializer::deserialize(
"options", stack,
)?);
}
"routes" => {
obj.routes.get_or_insert(vec![]).extend(
VpnStaticRouteListDeserializer::deserialize("routes", stack)?,
);
}
"state" => {
obj.state = Some(VpnStateDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"transitGatewayId" => {
obj.transit_gateway_id =
Some(StringDeserializer::deserialize("transitGatewayId", stack)?);
}
"type" => {
obj.type_ = Some(GatewayTypeDeserializer::deserialize("type", stack)?);
}
"vgwTelemetry" => {
obj.vgw_telemetry.get_or_insert(vec![]).extend(
VgwTelemetryListDeserializer::deserialize("vgwTelemetry", stack)?,
);
}
"vpnConnectionId" => {
obj.vpn_connection_id =
Some(StringDeserializer::deserialize("vpnConnectionId", stack)?);
}
"vpnGatewayId" => {
obj.vpn_gateway_id =
Some(StringDeserializer::deserialize("vpnGatewayId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpnConnectionIdStringListSerializer;
impl VpnConnectionIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct VpnConnectionListDeserializer;
impl VpnConnectionListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpnConnection>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpnConnectionDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpnConnectionOptions {
pub static_routes_only: Option<bool>,
}
struct VpnConnectionOptionsDeserializer;
impl VpnConnectionOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpnConnectionOptions, XmlParseError> {
deserialize_elements::<_, VpnConnectionOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"staticRoutesOnly" => {
obj.static_routes_only =
Some(BooleanDeserializer::deserialize("staticRoutesOnly", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpnConnectionOptionsSpecification {
pub static_routes_only: Option<bool>,
pub tunnel_options: Option<Vec<VpnTunnelOptionsSpecification>>,
}
struct VpnConnectionOptionsSpecificationSerializer;
impl VpnConnectionOptionsSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &VpnConnectionOptionsSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.static_routes_only {
params.put(&format!("{}{}", prefix, "StaticRoutesOnly"), &field_value);
}
if let Some(ref field_value) = obj.tunnel_options {
TunnelOptionsListSerializer::serialize(
params,
&format!("{}{}", prefix, "TunnelOptions"),
field_value,
);
}
}
}
struct VpnEcmpSupportValueDeserializer;
impl VpnEcmpSupportValueDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpnGateway {
pub amazon_side_asn: Option<i64>,
pub availability_zone: Option<String>,
pub state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub type_: Option<String>,
pub vpc_attachments: Option<Vec<VpcAttachment>>,
pub vpn_gateway_id: Option<String>,
}
struct VpnGatewayDeserializer;
impl VpnGatewayDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpnGateway, XmlParseError> {
deserialize_elements::<_, VpnGateway, _>(tag_name, stack, |name, stack, obj| {
match name {
"amazonSideAsn" => {
obj.amazon_side_asn =
Some(LongDeserializer::deserialize("amazonSideAsn", stack)?);
}
"availabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("availabilityZone", stack)?);
}
"state" => {
obj.state = Some(VpnStateDeserializer::deserialize("state", stack)?);
}
"tagSet" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("tagSet", stack)?);
}
"type" => {
obj.type_ = Some(GatewayTypeDeserializer::deserialize("type", stack)?);
}
"attachments" => {
obj.vpc_attachments.get_or_insert(vec![]).extend(
VpcAttachmentListDeserializer::deserialize("attachments", stack)?,
);
}
"vpnGatewayId" => {
obj.vpn_gateway_id =
Some(StringDeserializer::deserialize("vpnGatewayId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpnGatewayIdStringListSerializer;
impl VpnGatewayIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct VpnGatewayListDeserializer;
impl VpnGatewayListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpnGateway>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpnGatewayDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VpnProtocolDeserializer;
impl VpnProtocolDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct VpnStateDeserializer;
impl VpnStateDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpnStaticRoute {
pub destination_cidr_block: Option<String>,
pub source: Option<String>,
pub state: Option<String>,
}
struct VpnStaticRouteDeserializer;
impl VpnStaticRouteDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpnStaticRoute, XmlParseError> {
deserialize_elements::<_, VpnStaticRoute, _>(tag_name, stack, |name, stack, obj| {
match name {
"destinationCidrBlock" => {
obj.destination_cidr_block = Some(StringDeserializer::deserialize(
"destinationCidrBlock",
stack,
)?);
}
"source" => {
obj.source = Some(VpnStaticRouteSourceDeserializer::deserialize(
"source", stack,
)?);
}
"state" => {
obj.state = Some(VpnStateDeserializer::deserialize("state", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct VpnStaticRouteListDeserializer;
impl VpnStaticRouteListDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpnStaticRoute>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "item" {
obj.push(VpnStaticRouteDeserializer::deserialize("item", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct VpnStaticRouteSourceDeserializer;
impl VpnStaticRouteSourceDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VpnTunnelOptionsSpecification {
pub pre_shared_key: Option<String>,
pub tunnel_inside_cidr: Option<String>,
}
struct VpnTunnelOptionsSpecificationSerializer;
impl VpnTunnelOptionsSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &VpnTunnelOptionsSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.pre_shared_key {
params.put(&format!("{}{}", prefix, "PreSharedKey"), &field_value);
}
if let Some(ref field_value) = obj.tunnel_inside_cidr {
params.put(&format!("{}{}", prefix, "TunnelInsideCidr"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct WithdrawByoipCidrRequest {
pub cidr: String,
pub dry_run: Option<bool>,
}
struct WithdrawByoipCidrRequestSerializer;
impl WithdrawByoipCidrRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &WithdrawByoipCidrRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Cidr"), &obj.cidr);
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct WithdrawByoipCidrResult {
pub byoip_cidr: Option<ByoipCidr>,
}
struct WithdrawByoipCidrResultDeserializer;
impl WithdrawByoipCidrResultDeserializer {
#[allow(unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<WithdrawByoipCidrResult, XmlParseError> {
deserialize_elements::<_, WithdrawByoipCidrResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"byoipCidr" => {
obj.byoip_cidr =
Some(ByoipCidrDeserializer::deserialize("byoipCidr", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ZoneIdStringListSerializer;
impl ZoneIdStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ZoneNameStringListSerializer;
impl ZoneNameStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Debug, PartialEq)]
pub enum AcceptReservedInstancesExchangeQuoteError {}
impl AcceptReservedInstancesExchangeQuoteError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptReservedInstancesExchangeQuoteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AcceptReservedInstancesExchangeQuoteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AcceptReservedInstancesExchangeQuoteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AcceptTransitGatewayVpcAttachmentError {}
impl AcceptTransitGatewayVpcAttachmentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptTransitGatewayVpcAttachmentError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AcceptTransitGatewayVpcAttachmentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AcceptTransitGatewayVpcAttachmentError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AcceptVpcEndpointConnectionsError {}
impl AcceptVpcEndpointConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptVpcEndpointConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AcceptVpcEndpointConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AcceptVpcEndpointConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AcceptVpcPeeringConnectionError {}
impl AcceptVpcPeeringConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptVpcPeeringConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AcceptVpcPeeringConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AcceptVpcPeeringConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AdvertiseByoipCidrError {}
impl AdvertiseByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdvertiseByoipCidrError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AdvertiseByoipCidrError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AdvertiseByoipCidrError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AllocateAddressError {}
impl AllocateAddressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AllocateAddressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AllocateAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AllocateAddressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AllocateHostsError {}
impl AllocateHostsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AllocateHostsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AllocateHostsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AllocateHostsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ApplySecurityGroupsToClientVpnTargetNetworkError {}
impl ApplySecurityGroupsToClientVpnTargetNetworkError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ApplySecurityGroupsToClientVpnTargetNetworkError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ApplySecurityGroupsToClientVpnTargetNetworkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ApplySecurityGroupsToClientVpnTargetNetworkError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssignIpv6AddressesError {}
impl AssignIpv6AddressesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssignIpv6AddressesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssignIpv6AddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssignIpv6AddressesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssignPrivateIpAddressesError {}
impl AssignPrivateIpAddressesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssignPrivateIpAddressesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssignPrivateIpAddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssignPrivateIpAddressesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateAddressError {}
impl AssociateAddressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateAddressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateAddressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateClientVpnTargetNetworkError {}
impl AssociateClientVpnTargetNetworkError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateClientVpnTargetNetworkError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateClientVpnTargetNetworkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateClientVpnTargetNetworkError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateDhcpOptionsError {}
impl AssociateDhcpOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateDhcpOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateDhcpOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateDhcpOptionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateIamInstanceProfileError {}
impl AssociateIamInstanceProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateIamInstanceProfileError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateIamInstanceProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateIamInstanceProfileError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateRouteTableError {}
impl AssociateRouteTableError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateSubnetCidrBlockError {}
impl AssociateSubnetCidrBlockError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateSubnetCidrBlockError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateSubnetCidrBlockError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateSubnetCidrBlockError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateTransitGatewayRouteTableError {}
impl AssociateTransitGatewayRouteTableError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateTransitGatewayRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateTransitGatewayRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateTransitGatewayRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateVpcCidrBlockError {}
impl AssociateVpcCidrBlockError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateVpcCidrBlockError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AssociateVpcCidrBlockError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateVpcCidrBlockError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachClassicLinkVpcError {}
impl AttachClassicLinkVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachClassicLinkVpcError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AttachClassicLinkVpcError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachClassicLinkVpcError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachInternetGatewayError {}
impl AttachInternetGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachInternetGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AttachInternetGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachInternetGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachNetworkInterfaceError {}
impl AttachNetworkInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachNetworkInterfaceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AttachNetworkInterfaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachNetworkInterfaceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachVolumeError {}
impl AttachVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachVolumeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AttachVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachVolumeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachVpnGatewayError {}
impl AttachVpnGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachVpnGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AttachVpnGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachVpnGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AuthorizeClientVpnIngressError {}
impl AuthorizeClientVpnIngressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AuthorizeClientVpnIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AuthorizeClientVpnIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AuthorizeClientVpnIngressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AuthorizeSecurityGroupEgressError {}
impl AuthorizeSecurityGroupEgressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AuthorizeSecurityGroupEgressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AuthorizeSecurityGroupEgressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AuthorizeSecurityGroupEgressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum AuthorizeSecurityGroupIngressError {}
impl AuthorizeSecurityGroupIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AuthorizeSecurityGroupIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AuthorizeSecurityGroupIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AuthorizeSecurityGroupIngressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum BundleInstanceError {}
impl BundleInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BundleInstanceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for BundleInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BundleInstanceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelBundleTaskError {}
impl CancelBundleTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelBundleTaskError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelBundleTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelBundleTaskError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelCapacityReservationError {}
impl CancelCapacityReservationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelCapacityReservationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelCapacityReservationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelCapacityReservationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelConversionTaskError {}
impl CancelConversionTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelConversionTaskError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelConversionTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelConversionTaskError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelExportTaskError {}
impl CancelExportTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelExportTaskError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelExportTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelExportTaskError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelImportTaskError {}
impl CancelImportTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelImportTaskError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelImportTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelImportTaskError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelReservedInstancesListingError {}
impl CancelReservedInstancesListingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CancelReservedInstancesListingError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelReservedInstancesListingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelReservedInstancesListingError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EC2CancelSpotFleetRequestsError {}
impl EC2CancelSpotFleetRequestsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EC2CancelSpotFleetRequestsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EC2CancelSpotFleetRequestsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EC2CancelSpotFleetRequestsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelSpotInstanceRequestsError {}
impl CancelSpotInstanceRequestsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CancelSpotInstanceRequestsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelSpotInstanceRequestsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelSpotInstanceRequestsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ConfirmProductInstanceError {}
impl ConfirmProductInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConfirmProductInstanceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ConfirmProductInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ConfirmProductInstanceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyFpgaImageError {}
impl CopyFpgaImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopyFpgaImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CopyFpgaImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyFpgaImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyImageError {}
impl CopyImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopyImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CopyImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CopySnapshotError {}
impl CopySnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopySnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CopySnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopySnapshotError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCapacityReservationError {}
impl CreateCapacityReservationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCapacityReservationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateCapacityReservationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateCapacityReservationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClientVpnEndpointError {}
impl CreateClientVpnEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateClientVpnEndpointError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateClientVpnEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClientVpnEndpointError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClientVpnRouteError {}
impl CreateClientVpnRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateClientVpnRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateClientVpnRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClientVpnRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCustomerGatewayError {}
impl CreateCustomerGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCustomerGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateCustomerGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateCustomerGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDefaultSubnetError {}
impl CreateDefaultSubnetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDefaultSubnetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateDefaultSubnetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDefaultSubnetError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDefaultVpcError {}
impl CreateDefaultVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDefaultVpcError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateDefaultVpcError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDefaultVpcError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDhcpOptionsError {}
impl CreateDhcpOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDhcpOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateDhcpOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDhcpOptionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateEgressOnlyInternetGatewayError {}
impl CreateEgressOnlyInternetGatewayError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateEgressOnlyInternetGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateEgressOnlyInternetGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateEgressOnlyInternetGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateFleetError {}
impl CreateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFleetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateFleetError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateFlowLogsError {}
impl CreateFlowLogsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFlowLogsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateFlowLogsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateFlowLogsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateFpgaImageError {}
impl CreateFpgaImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFpgaImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateFpgaImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateFpgaImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateImageError {}
impl CreateImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateInstanceExportTaskError {}
impl CreateInstanceExportTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInstanceExportTaskError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateInstanceExportTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateInstanceExportTaskError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateInternetGatewayError {}
impl CreateInternetGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInternetGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateInternetGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateInternetGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateKeyPairError {}
impl CreateKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateKeyPairError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateKeyPairError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateKeyPairError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateLaunchTemplateError {}
impl CreateLaunchTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLaunchTemplateError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateLaunchTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateLaunchTemplateError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateLaunchTemplateVersionError {}
impl CreateLaunchTemplateVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateLaunchTemplateVersionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateLaunchTemplateVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateLaunchTemplateVersionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateNatGatewayError {}
impl CreateNatGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNatGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateNatGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateNatGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateNetworkAclError {}
impl CreateNetworkAclError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNetworkAclError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateNetworkAclError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateNetworkAclError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateNetworkAclEntryError {}
impl CreateNetworkAclEntryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNetworkAclEntryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateNetworkAclEntryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateNetworkAclEntryError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateNetworkInterfaceError {}
impl CreateNetworkInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNetworkInterfaceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateNetworkInterfaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateNetworkInterfaceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateNetworkInterfacePermissionError {}
impl CreateNetworkInterfacePermissionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateNetworkInterfacePermissionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateNetworkInterfacePermissionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateNetworkInterfacePermissionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreatePlacementGroupError {}
impl CreatePlacementGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePlacementGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreatePlacementGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreatePlacementGroupError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateReservedInstancesListingError {}
impl CreateReservedInstancesListingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateReservedInstancesListingError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateReservedInstancesListingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateReservedInstancesListingError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateRouteError {}
impl CreateRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateRouteTableError {}
impl CreateRouteTableError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSecurityGroupError {}
impl CreateSecurityGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSecurityGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateSecurityGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSecurityGroupError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotError {}
impl CreateSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSnapshotError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotsError {}
impl CreateSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateSnapshotsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSnapshotsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSpotDatafeedSubscriptionError {}
impl CreateSpotDatafeedSubscriptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateSpotDatafeedSubscriptionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateSpotDatafeedSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSpotDatafeedSubscriptionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSubnetError {}
impl CreateSubnetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSubnetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateSubnetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSubnetError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTagsError {}
impl CreateTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTagsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTagsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTransitGatewayError {}
impl CreateTransitGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTransitGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateTransitGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTransitGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTransitGatewayRouteError {}
impl CreateTransitGatewayRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTransitGatewayRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateTransitGatewayRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTransitGatewayRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTransitGatewayRouteTableError {}
impl CreateTransitGatewayRouteTableError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateTransitGatewayRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateTransitGatewayRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTransitGatewayRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTransitGatewayVpcAttachmentError {}
impl CreateTransitGatewayVpcAttachmentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateTransitGatewayVpcAttachmentError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateTransitGatewayVpcAttachmentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTransitGatewayVpcAttachmentError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVolumeError {}
impl CreateVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVolumeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVolumeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpcError {}
impl CreateVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVpcError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpcError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpcError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpcEndpointError {}
impl CreateVpcEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVpcEndpointError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpcEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpcEndpointError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpcEndpointConnectionNotificationError {}
impl CreateVpcEndpointConnectionNotificationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateVpcEndpointConnectionNotificationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpcEndpointConnectionNotificationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpcEndpointConnectionNotificationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpcEndpointServiceConfigurationError {}
impl CreateVpcEndpointServiceConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateVpcEndpointServiceConfigurationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpcEndpointServiceConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpcEndpointServiceConfigurationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpcPeeringConnectionError {}
impl CreateVpcPeeringConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateVpcPeeringConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpcPeeringConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpcPeeringConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpnConnectionError {}
impl CreateVpnConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVpnConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpnConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpnConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpnConnectionRouteError {}
impl CreateVpnConnectionRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVpnConnectionRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpnConnectionRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpnConnectionRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVpnGatewayError {}
impl CreateVpnGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVpnGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateVpnGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVpnGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClientVpnEndpointError {}
impl DeleteClientVpnEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteClientVpnEndpointError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteClientVpnEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClientVpnEndpointError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClientVpnRouteError {}
impl DeleteClientVpnRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteClientVpnRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteClientVpnRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClientVpnRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteCustomerGatewayError {}
impl DeleteCustomerGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCustomerGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteCustomerGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteCustomerGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDhcpOptionsError {}
impl DeleteDhcpOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDhcpOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteDhcpOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDhcpOptionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteEgressOnlyInternetGatewayError {}
impl DeleteEgressOnlyInternetGatewayError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteEgressOnlyInternetGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteEgressOnlyInternetGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteEgressOnlyInternetGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteFleetsError {}
impl DeleteFleetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFleetsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteFleetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteFleetsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteFlowLogsError {}
impl DeleteFlowLogsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFlowLogsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteFlowLogsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteFlowLogsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteFpgaImageError {}
impl DeleteFpgaImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFpgaImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteFpgaImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteFpgaImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteInternetGatewayError {}
impl DeleteInternetGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInternetGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteInternetGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteInternetGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteKeyPairError {}
impl DeleteKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteKeyPairError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteKeyPairError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteKeyPairError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLaunchTemplateError {}
impl DeleteLaunchTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLaunchTemplateError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteLaunchTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLaunchTemplateError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLaunchTemplateVersionsError {}
impl DeleteLaunchTemplateVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteLaunchTemplateVersionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteLaunchTemplateVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLaunchTemplateVersionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNatGatewayError {}
impl DeleteNatGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNatGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteNatGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNatGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNetworkAclError {}
impl DeleteNetworkAclError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNetworkAclError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteNetworkAclError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNetworkAclError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNetworkAclEntryError {}
impl DeleteNetworkAclEntryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNetworkAclEntryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteNetworkAclEntryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNetworkAclEntryError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNetworkInterfaceError {}
impl DeleteNetworkInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNetworkInterfaceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteNetworkInterfaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNetworkInterfaceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNetworkInterfacePermissionError {}
impl DeleteNetworkInterfacePermissionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteNetworkInterfacePermissionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteNetworkInterfacePermissionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNetworkInterfacePermissionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeletePlacementGroupError {}
impl DeletePlacementGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePlacementGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeletePlacementGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeletePlacementGroupError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteRouteError {}
impl DeleteRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteRouteTableError {}
impl DeleteRouteTableError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSecurityGroupError {}
impl DeleteSecurityGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSecurityGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteSecurityGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSecurityGroupError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotError {}
impl DeleteSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSnapshotError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSpotDatafeedSubscriptionError {}
impl DeleteSpotDatafeedSubscriptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteSpotDatafeedSubscriptionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteSpotDatafeedSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSpotDatafeedSubscriptionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSubnetError {}
impl DeleteSubnetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSubnetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteSubnetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSubnetError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {}
impl DeleteTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTagsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTagsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTransitGatewayError {}
impl DeleteTransitGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTransitGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteTransitGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTransitGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTransitGatewayRouteError {}
impl DeleteTransitGatewayRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTransitGatewayRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteTransitGatewayRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTransitGatewayRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTransitGatewayRouteTableError {}
impl DeleteTransitGatewayRouteTableError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteTransitGatewayRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteTransitGatewayRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTransitGatewayRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTransitGatewayVpcAttachmentError {}
impl DeleteTransitGatewayVpcAttachmentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteTransitGatewayVpcAttachmentError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteTransitGatewayVpcAttachmentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTransitGatewayVpcAttachmentError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVolumeError {}
impl DeleteVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVolumeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVolumeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpcError {}
impl DeleteVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVpcError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpcError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpcError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpcEndpointConnectionNotificationsError {}
impl DeleteVpcEndpointConnectionNotificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteVpcEndpointConnectionNotificationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpcEndpointConnectionNotificationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpcEndpointConnectionNotificationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpcEndpointServiceConfigurationsError {}
impl DeleteVpcEndpointServiceConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteVpcEndpointServiceConfigurationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpcEndpointServiceConfigurationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpcEndpointServiceConfigurationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpcEndpointsError {}
impl DeleteVpcEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVpcEndpointsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpcEndpointsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpcEndpointsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpcPeeringConnectionError {}
impl DeleteVpcPeeringConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteVpcPeeringConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpcPeeringConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpcPeeringConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpnConnectionError {}
impl DeleteVpnConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVpnConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpnConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpnConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpnConnectionRouteError {}
impl DeleteVpnConnectionRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVpnConnectionRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpnConnectionRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpnConnectionRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVpnGatewayError {}
impl DeleteVpnGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVpnGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteVpnGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVpnGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeprovisionByoipCidrError {}
impl DeprovisionByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeprovisionByoipCidrError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeprovisionByoipCidrError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeprovisionByoipCidrError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterImageError {}
impl DeregisterImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeregisterImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountAttributesError {}
impl DescribeAccountAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAccountAttributesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAccountAttributesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAccountAttributesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAddressesError {}
impl DescribeAddressesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAddressesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAddressesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAggregateIdFormatError {}
impl DescribeAggregateIdFormatError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAggregateIdFormatError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAggregateIdFormatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAggregateIdFormatError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAvailabilityZonesError {}
impl DescribeAvailabilityZonesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAvailabilityZonesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAvailabilityZonesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAvailabilityZonesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeBundleTasksError {}
impl DescribeBundleTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeBundleTasksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeBundleTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeBundleTasksError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeByoipCidrsError {}
impl DescribeByoipCidrsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeByoipCidrsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeByoipCidrsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeByoipCidrsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeCapacityReservationsError {}
impl DescribeCapacityReservationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCapacityReservationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCapacityReservationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeCapacityReservationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClassicLinkInstancesError {}
impl DescribeClassicLinkInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClassicLinkInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeClassicLinkInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClassicLinkInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClientVpnAuthorizationRulesError {}
impl DescribeClientVpnAuthorizationRulesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClientVpnAuthorizationRulesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeClientVpnAuthorizationRulesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClientVpnAuthorizationRulesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClientVpnConnectionsError {}
impl DescribeClientVpnConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClientVpnConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeClientVpnConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClientVpnConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClientVpnEndpointsError {}
impl DescribeClientVpnEndpointsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClientVpnEndpointsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeClientVpnEndpointsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClientVpnEndpointsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClientVpnRoutesError {}
impl DescribeClientVpnRoutesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClientVpnRoutesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeClientVpnRoutesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClientVpnRoutesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClientVpnTargetNetworksError {}
impl DescribeClientVpnTargetNetworksError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClientVpnTargetNetworksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeClientVpnTargetNetworksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClientVpnTargetNetworksError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeConversionTasksError {}
impl DescribeConversionTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConversionTasksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeConversionTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeConversionTasksError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeCustomerGatewaysError {}
impl DescribeCustomerGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCustomerGatewaysError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCustomerGatewaysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeCustomerGatewaysError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDhcpOptionsError {}
impl DescribeDhcpOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDhcpOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeDhcpOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDhcpOptionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEgressOnlyInternetGatewaysError {}
impl DescribeEgressOnlyInternetGatewaysError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeEgressOnlyInternetGatewaysError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeEgressOnlyInternetGatewaysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEgressOnlyInternetGatewaysError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticGpusError {}
impl DescribeElasticGpusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeElasticGpusError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeElasticGpusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeElasticGpusError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeExportTasksError {}
impl DescribeExportTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeExportTasksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeExportTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeExportTasksError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFleetHistoryError {}
impl DescribeFleetHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFleetHistoryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeFleetHistoryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFleetHistoryError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFleetInstancesError {}
impl DescribeFleetInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFleetInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeFleetInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFleetInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFleetsError {}
impl DescribeFleetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFleetsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeFleetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFleetsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFlowLogsError {}
impl DescribeFlowLogsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFlowLogsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeFlowLogsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFlowLogsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFpgaImageAttributeError {}
impl DescribeFpgaImageAttributeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeFpgaImageAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeFpgaImageAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFpgaImageAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFpgaImagesError {}
impl DescribeFpgaImagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFpgaImagesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeFpgaImagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFpgaImagesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeHostReservationOfferingsError {}
impl DescribeHostReservationOfferingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeHostReservationOfferingsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeHostReservationOfferingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeHostReservationOfferingsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeHostReservationsError {}
impl DescribeHostReservationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHostReservationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeHostReservationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeHostReservationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeHostsError {}
impl DescribeHostsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHostsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeHostsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeHostsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeIamInstanceProfileAssociationsError {}
impl DescribeIamInstanceProfileAssociationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeIamInstanceProfileAssociationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeIamInstanceProfileAssociationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeIamInstanceProfileAssociationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeIdFormatError {}
impl DescribeIdFormatError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIdFormatError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeIdFormatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeIdFormatError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeIdentityIdFormatError {}
impl DescribeIdentityIdFormatError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIdentityIdFormatError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeIdentityIdFormatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeIdentityIdFormatError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImageAttributeError {}
impl DescribeImageAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeImageAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeImageAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImageAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImagesError {}
impl DescribeImagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeImagesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeImagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImagesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImportImageTasksError {}
impl DescribeImportImageTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeImportImageTasksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeImportImageTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImportImageTasksError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImportSnapshotTasksError {}
impl DescribeImportSnapshotTasksError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeImportSnapshotTasksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeImportSnapshotTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImportSnapshotTasksError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeInstanceAttributeError {}
impl DescribeInstanceAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInstanceAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeInstanceAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeInstanceAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeInstanceCreditSpecificationsError {}
impl DescribeInstanceCreditSpecificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeInstanceCreditSpecificationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeInstanceCreditSpecificationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeInstanceCreditSpecificationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeInstanceStatusError {}
impl DescribeInstanceStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInstanceStatusError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeInstanceStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeInstanceStatusError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeInstancesError {}
impl DescribeInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeInternetGatewaysError {}
impl DescribeInternetGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInternetGatewaysError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeInternetGatewaysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeInternetGatewaysError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeKeyPairsError {}
impl DescribeKeyPairsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeKeyPairsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeKeyPairsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeKeyPairsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLaunchTemplateVersionsError {}
impl DescribeLaunchTemplateVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeLaunchTemplateVersionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeLaunchTemplateVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLaunchTemplateVersionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLaunchTemplatesError {}
impl DescribeLaunchTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLaunchTemplatesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeLaunchTemplatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLaunchTemplatesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeMovingAddressesError {}
impl DescribeMovingAddressesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeMovingAddressesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeMovingAddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeMovingAddressesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeNatGatewaysError {}
impl DescribeNatGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNatGatewaysError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeNatGatewaysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeNatGatewaysError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeNetworkAclsError {}
impl DescribeNetworkAclsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNetworkAclsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeNetworkAclsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeNetworkAclsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeNetworkInterfaceAttributeError {}
impl DescribeNetworkInterfaceAttributeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeNetworkInterfaceAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeNetworkInterfaceAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeNetworkInterfaceAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeNetworkInterfacePermissionsError {}
impl DescribeNetworkInterfacePermissionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeNetworkInterfacePermissionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeNetworkInterfacePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeNetworkInterfacePermissionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeNetworkInterfacesError {}
impl DescribeNetworkInterfacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNetworkInterfacesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeNetworkInterfacesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeNetworkInterfacesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePlacementGroupsError {}
impl DescribePlacementGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePlacementGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribePlacementGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePlacementGroupsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePrefixListsError {}
impl DescribePrefixListsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePrefixListsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribePrefixListsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePrefixListsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePrincipalIdFormatError {}
impl DescribePrincipalIdFormatError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePrincipalIdFormatError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribePrincipalIdFormatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePrincipalIdFormatError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePublicIpv4PoolsError {}
impl DescribePublicIpv4PoolsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePublicIpv4PoolsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribePublicIpv4PoolsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePublicIpv4PoolsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeRegionsError {}
impl DescribeRegionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRegionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeRegionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRegionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedInstancesError {}
impl DescribeReservedInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeReservedInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReservedInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReservedInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedInstancesListingsError {}
impl DescribeReservedInstancesListingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedInstancesListingsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReservedInstancesListingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReservedInstancesListingsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedInstancesModificationsError {}
impl DescribeReservedInstancesModificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedInstancesModificationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReservedInstancesModificationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReservedInstancesModificationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedInstancesOfferingsError {}
impl DescribeReservedInstancesOfferingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedInstancesOfferingsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReservedInstancesOfferingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReservedInstancesOfferingsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeRouteTablesError {}
impl DescribeRouteTablesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRouteTablesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeRouteTablesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRouteTablesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeScheduledInstanceAvailabilityError {}
impl DescribeScheduledInstanceAvailabilityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeScheduledInstanceAvailabilityError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeScheduledInstanceAvailabilityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeScheduledInstanceAvailabilityError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeScheduledInstancesError {}
impl DescribeScheduledInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeScheduledInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeScheduledInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeScheduledInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSecurityGroupReferencesError {}
impl DescribeSecurityGroupReferencesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSecurityGroupReferencesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSecurityGroupReferencesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSecurityGroupReferencesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSecurityGroupsError {}
impl DescribeSecurityGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSecurityGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSecurityGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSecurityGroupsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotAttributeError {}
impl DescribeSnapshotAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSnapshotAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSnapshotAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSnapshotAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotsError {}
impl DescribeSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSnapshotsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSnapshotsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSnapshotsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSpotDatafeedSubscriptionError {}
impl DescribeSpotDatafeedSubscriptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSpotDatafeedSubscriptionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSpotDatafeedSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSpotDatafeedSubscriptionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSpotFleetInstancesError {}
impl DescribeSpotFleetInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSpotFleetInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSpotFleetInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSpotFleetInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSpotFleetRequestHistoryError {}
impl DescribeSpotFleetRequestHistoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSpotFleetRequestHistoryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSpotFleetRequestHistoryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSpotFleetRequestHistoryError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSpotFleetRequestsError {}
impl DescribeSpotFleetRequestsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSpotFleetRequestsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSpotFleetRequestsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSpotFleetRequestsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSpotInstanceRequestsError {}
impl DescribeSpotInstanceRequestsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSpotInstanceRequestsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSpotInstanceRequestsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSpotInstanceRequestsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSpotPriceHistoryError {}
impl DescribeSpotPriceHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSpotPriceHistoryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSpotPriceHistoryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSpotPriceHistoryError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeStaleSecurityGroupsError {}
impl DescribeStaleSecurityGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeStaleSecurityGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStaleSecurityGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeStaleSecurityGroupsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSubnetsError {}
impl DescribeSubnetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSubnetsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSubnetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSubnetsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTagsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTagsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTransitGatewayAttachmentsError {}
impl DescribeTransitGatewayAttachmentsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeTransitGatewayAttachmentsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTransitGatewayAttachmentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTransitGatewayAttachmentsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTransitGatewayRouteTablesError {}
impl DescribeTransitGatewayRouteTablesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeTransitGatewayRouteTablesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTransitGatewayRouteTablesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTransitGatewayRouteTablesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTransitGatewayVpcAttachmentsError {}
impl DescribeTransitGatewayVpcAttachmentsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeTransitGatewayVpcAttachmentsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTransitGatewayVpcAttachmentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTransitGatewayVpcAttachmentsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTransitGatewaysError {}
impl DescribeTransitGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTransitGatewaysError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTransitGatewaysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTransitGatewaysError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVolumeAttributeError {}
impl DescribeVolumeAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVolumeAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVolumeAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVolumeAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVolumeStatusError {}
impl DescribeVolumeStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVolumeStatusError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVolumeStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVolumeStatusError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVolumesError {}
impl DescribeVolumesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVolumesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVolumesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVolumesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVolumesModificationsError {}
impl DescribeVolumesModificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVolumesModificationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVolumesModificationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVolumesModificationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcAttributeError {}
impl DescribeVpcAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVpcAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcClassicLinkError {}
impl DescribeVpcClassicLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVpcClassicLinkError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcClassicLinkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcClassicLinkError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcClassicLinkDnsSupportError {}
impl DescribeVpcClassicLinkDnsSupportError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcClassicLinkDnsSupportError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcClassicLinkDnsSupportError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcClassicLinkDnsSupportError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcEndpointConnectionNotificationsError {}
impl DescribeVpcEndpointConnectionNotificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcEndpointConnectionNotificationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcEndpointConnectionNotificationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcEndpointConnectionNotificationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcEndpointConnectionsError {}
impl DescribeVpcEndpointConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcEndpointConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcEndpointConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcEndpointConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcEndpointServiceConfigurationsError {}
impl DescribeVpcEndpointServiceConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcEndpointServiceConfigurationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcEndpointServiceConfigurationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcEndpointServiceConfigurationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcEndpointServicePermissionsError {}
impl DescribeVpcEndpointServicePermissionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcEndpointServicePermissionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcEndpointServicePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcEndpointServicePermissionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcEndpointServicesError {}
impl DescribeVpcEndpointServicesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcEndpointServicesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcEndpointServicesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcEndpointServicesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcEndpointsError {}
impl DescribeVpcEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVpcEndpointsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcEndpointsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcEndpointsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcPeeringConnectionsError {}
impl DescribeVpcPeeringConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeVpcPeeringConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcPeeringConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcPeeringConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpcsError {}
impl DescribeVpcsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVpcsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpcsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpcsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpnConnectionsError {}
impl DescribeVpnConnectionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVpnConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpnConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpnConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVpnGatewaysError {}
impl DescribeVpnGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVpnGatewaysError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeVpnGatewaysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVpnGatewaysError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachClassicLinkVpcError {}
impl DetachClassicLinkVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachClassicLinkVpcError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetachClassicLinkVpcError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachClassicLinkVpcError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachInternetGatewayError {}
impl DetachInternetGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachInternetGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetachInternetGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachInternetGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachNetworkInterfaceError {}
impl DetachNetworkInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachNetworkInterfaceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetachNetworkInterfaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachNetworkInterfaceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachVolumeError {}
impl DetachVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachVolumeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetachVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachVolumeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachVpnGatewayError {}
impl DetachVpnGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachVpnGatewayError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetachVpnGatewayError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachVpnGatewayError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableEbsEncryptionByDefaultError {}
impl DisableEbsEncryptionByDefaultError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisableEbsEncryptionByDefaultError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableEbsEncryptionByDefaultError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableEbsEncryptionByDefaultError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableTransitGatewayRouteTablePropagationError {}
impl DisableTransitGatewayRouteTablePropagationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisableTransitGatewayRouteTablePropagationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableTransitGatewayRouteTablePropagationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableTransitGatewayRouteTablePropagationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableVgwRoutePropagationError {}
impl DisableVgwRoutePropagationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisableVgwRoutePropagationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableVgwRoutePropagationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableVgwRoutePropagationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableVpcClassicLinkError {}
impl DisableVpcClassicLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableVpcClassicLinkError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableVpcClassicLinkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableVpcClassicLinkError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableVpcClassicLinkDnsSupportError {}
impl DisableVpcClassicLinkDnsSupportError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisableVpcClassicLinkDnsSupportError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableVpcClassicLinkDnsSupportError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableVpcClassicLinkDnsSupportError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateAddressError {}
impl DisassociateAddressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateAddressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateAddressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateClientVpnTargetNetworkError {}
impl DisassociateClientVpnTargetNetworkError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateClientVpnTargetNetworkError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateClientVpnTargetNetworkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateClientVpnTargetNetworkError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateIamInstanceProfileError {}
impl DisassociateIamInstanceProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateIamInstanceProfileError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateIamInstanceProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateIamInstanceProfileError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateRouteTableError {}
impl DisassociateRouteTableError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateSubnetCidrBlockError {}
impl DisassociateSubnetCidrBlockError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateSubnetCidrBlockError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateSubnetCidrBlockError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateSubnetCidrBlockError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateTransitGatewayRouteTableError {}
impl DisassociateTransitGatewayRouteTableError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateTransitGatewayRouteTableError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateTransitGatewayRouteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateTransitGatewayRouteTableError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateVpcCidrBlockError {}
impl DisassociateVpcCidrBlockError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateVpcCidrBlockError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateVpcCidrBlockError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateVpcCidrBlockError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableEbsEncryptionByDefaultError {}
impl EnableEbsEncryptionByDefaultError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EnableEbsEncryptionByDefaultError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableEbsEncryptionByDefaultError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableEbsEncryptionByDefaultError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableTransitGatewayRouteTablePropagationError {}
impl EnableTransitGatewayRouteTablePropagationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EnableTransitGatewayRouteTablePropagationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableTransitGatewayRouteTablePropagationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableTransitGatewayRouteTablePropagationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableVgwRoutePropagationError {}
impl EnableVgwRoutePropagationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableVgwRoutePropagationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableVgwRoutePropagationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableVgwRoutePropagationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableVolumeIOError {}
impl EnableVolumeIOError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableVolumeIOError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableVolumeIOError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableVolumeIOError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableVpcClassicLinkError {}
impl EnableVpcClassicLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableVpcClassicLinkError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableVpcClassicLinkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableVpcClassicLinkError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableVpcClassicLinkDnsSupportError {}
impl EnableVpcClassicLinkDnsSupportError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EnableVpcClassicLinkDnsSupportError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableVpcClassicLinkDnsSupportError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableVpcClassicLinkDnsSupportError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ExportClientVpnClientCertificateRevocationListError {}
impl ExportClientVpnClientCertificateRevocationListError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExportClientVpnClientCertificateRevocationListError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ExportClientVpnClientCertificateRevocationListError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExportClientVpnClientCertificateRevocationListError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ExportClientVpnClientConfigurationError {}
impl ExportClientVpnClientConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExportClientVpnClientConfigurationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ExportClientVpnClientConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExportClientVpnClientConfigurationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ExportTransitGatewayRoutesError {}
impl ExportTransitGatewayRoutesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExportTransitGatewayRoutesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ExportTransitGatewayRoutesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExportTransitGatewayRoutesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConsoleOutputError {}
impl GetConsoleOutputError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConsoleOutputError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetConsoleOutputError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConsoleOutputError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConsoleScreenshotError {}
impl GetConsoleScreenshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConsoleScreenshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetConsoleScreenshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConsoleScreenshotError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetEbsDefaultKmsKeyIdError {}
impl GetEbsDefaultKmsKeyIdError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEbsDefaultKmsKeyIdError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetEbsDefaultKmsKeyIdError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetEbsDefaultKmsKeyIdError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetEbsEncryptionByDefaultError {}
impl GetEbsEncryptionByDefaultError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEbsEncryptionByDefaultError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetEbsEncryptionByDefaultError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetEbsEncryptionByDefaultError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHostReservationPurchasePreviewError {}
impl GetHostReservationPurchasePreviewError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetHostReservationPurchasePreviewError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetHostReservationPurchasePreviewError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHostReservationPurchasePreviewError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetLaunchTemplateDataError {}
impl GetLaunchTemplateDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLaunchTemplateDataError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetLaunchTemplateDataError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetLaunchTemplateDataError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetPasswordDataError {}
impl GetPasswordDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPasswordDataError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetPasswordDataError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetPasswordDataError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetReservedInstancesExchangeQuoteError {}
impl GetReservedInstancesExchangeQuoteError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetReservedInstancesExchangeQuoteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetReservedInstancesExchangeQuoteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetReservedInstancesExchangeQuoteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTransitGatewayAttachmentPropagationsError {}
impl GetTransitGatewayAttachmentPropagationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetTransitGatewayAttachmentPropagationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetTransitGatewayAttachmentPropagationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTransitGatewayAttachmentPropagationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTransitGatewayRouteTableAssociationsError {}
impl GetTransitGatewayRouteTableAssociationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetTransitGatewayRouteTableAssociationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetTransitGatewayRouteTableAssociationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTransitGatewayRouteTableAssociationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTransitGatewayRouteTablePropagationsError {}
impl GetTransitGatewayRouteTablePropagationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetTransitGatewayRouteTablePropagationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetTransitGatewayRouteTablePropagationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTransitGatewayRouteTablePropagationsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportClientVpnClientCertificateRevocationListError {}
impl ImportClientVpnClientCertificateRevocationListError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ImportClientVpnClientCertificateRevocationListError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ImportClientVpnClientCertificateRevocationListError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportClientVpnClientCertificateRevocationListError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportImageError {}
impl ImportImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ImportImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportInstanceError {}
impl ImportInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportInstanceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ImportInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportInstanceError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportKeyPairError {}
impl ImportKeyPairError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportKeyPairError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ImportKeyPairError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportKeyPairError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportSnapshotError {}
impl ImportSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportSnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ImportSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportSnapshotError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportVolumeError {}
impl ImportVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportVolumeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ImportVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportVolumeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyCapacityReservationError {}
impl ModifyCapacityReservationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyCapacityReservationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyCapacityReservationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyCapacityReservationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyClientVpnEndpointError {}
impl ModifyClientVpnEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClientVpnEndpointError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyClientVpnEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyClientVpnEndpointError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyEbsDefaultKmsKeyIdError {}
impl ModifyEbsDefaultKmsKeyIdError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyEbsDefaultKmsKeyIdError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyEbsDefaultKmsKeyIdError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyEbsDefaultKmsKeyIdError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyFleetError {}
impl ModifyFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyFleetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyFleetError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyFpgaImageAttributeError {}
impl ModifyFpgaImageAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyFpgaImageAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyFpgaImageAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyFpgaImageAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyHostsError {}
impl ModifyHostsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyHostsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyHostsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyHostsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyIdFormatError {}
impl ModifyIdFormatError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyIdFormatError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyIdFormatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyIdFormatError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyIdentityIdFormatError {}
impl ModifyIdentityIdFormatError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyIdentityIdFormatError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyIdentityIdFormatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyIdentityIdFormatError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyImageAttributeError {}
impl ModifyImageAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyImageAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyImageAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyImageAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyInstanceAttributeError {}
impl ModifyInstanceAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyInstanceAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyInstanceAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyInstanceAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyInstanceCapacityReservationAttributesError {}
impl ModifyInstanceCapacityReservationAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyInstanceCapacityReservationAttributesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyInstanceCapacityReservationAttributesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyInstanceCapacityReservationAttributesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyInstanceCreditSpecificationError {}
impl ModifyInstanceCreditSpecificationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyInstanceCreditSpecificationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyInstanceCreditSpecificationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyInstanceCreditSpecificationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyInstanceEventStartTimeError {}
impl ModifyInstanceEventStartTimeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyInstanceEventStartTimeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyInstanceEventStartTimeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyInstanceEventStartTimeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyInstancePlacementError {}
impl ModifyInstancePlacementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyInstancePlacementError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyInstancePlacementError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyInstancePlacementError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyLaunchTemplateError {}
impl ModifyLaunchTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyLaunchTemplateError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyLaunchTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyLaunchTemplateError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyNetworkInterfaceAttributeError {}
impl ModifyNetworkInterfaceAttributeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyNetworkInterfaceAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyNetworkInterfaceAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyNetworkInterfaceAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyReservedInstancesError {}
impl ModifyReservedInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyReservedInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyReservedInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyReservedInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifySnapshotAttributeError {}
impl ModifySnapshotAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifySnapshotAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifySnapshotAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifySnapshotAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifySpotFleetRequestError {}
impl ModifySpotFleetRequestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifySpotFleetRequestError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifySpotFleetRequestError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifySpotFleetRequestError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifySubnetAttributeError {}
impl ModifySubnetAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifySubnetAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifySubnetAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifySubnetAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyTransitGatewayVpcAttachmentError {}
impl ModifyTransitGatewayVpcAttachmentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyTransitGatewayVpcAttachmentError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyTransitGatewayVpcAttachmentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyTransitGatewayVpcAttachmentError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVolumeError {}
impl ModifyVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyVolumeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVolumeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVolumeAttributeError {}
impl ModifyVolumeAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyVolumeAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVolumeAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVolumeAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcAttributeError {}
impl ModifyVpcAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyVpcAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcEndpointError {}
impl ModifyVpcEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyVpcEndpointError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcEndpointError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcEndpointConnectionNotificationError {}
impl ModifyVpcEndpointConnectionNotificationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyVpcEndpointConnectionNotificationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcEndpointConnectionNotificationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcEndpointConnectionNotificationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcEndpointServiceConfigurationError {}
impl ModifyVpcEndpointServiceConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyVpcEndpointServiceConfigurationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcEndpointServiceConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcEndpointServiceConfigurationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcEndpointServicePermissionsError {}
impl ModifyVpcEndpointServicePermissionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyVpcEndpointServicePermissionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcEndpointServicePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcEndpointServicePermissionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcPeeringConnectionOptionsError {}
impl ModifyVpcPeeringConnectionOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyVpcPeeringConnectionOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcPeeringConnectionOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcPeeringConnectionOptionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpcTenancyError {}
impl ModifyVpcTenancyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyVpcTenancyError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpcTenancyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpcTenancyError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyVpnConnectionError {}
impl ModifyVpnConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyVpnConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyVpnConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyVpnConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum MonitorInstancesError {}
impl MonitorInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<MonitorInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for MonitorInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for MonitorInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum MoveAddressToVpcError {}
impl MoveAddressToVpcError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<MoveAddressToVpcError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for MoveAddressToVpcError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for MoveAddressToVpcError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ProvisionByoipCidrError {}
impl ProvisionByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ProvisionByoipCidrError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ProvisionByoipCidrError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ProvisionByoipCidrError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum PurchaseHostReservationError {}
impl PurchaseHostReservationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PurchaseHostReservationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PurchaseHostReservationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PurchaseHostReservationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum PurchaseReservedInstancesOfferingError {}
impl PurchaseReservedInstancesOfferingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PurchaseReservedInstancesOfferingError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PurchaseReservedInstancesOfferingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PurchaseReservedInstancesOfferingError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum PurchaseScheduledInstancesError {}
impl PurchaseScheduledInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PurchaseScheduledInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PurchaseScheduledInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PurchaseScheduledInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RebootInstancesError {}
impl RebootInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebootInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RebootInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RebootInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterImageError {}
impl RegisterImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RegisterImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterImageError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RejectTransitGatewayVpcAttachmentError {}
impl RejectTransitGatewayVpcAttachmentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RejectTransitGatewayVpcAttachmentError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RejectTransitGatewayVpcAttachmentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RejectTransitGatewayVpcAttachmentError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RejectVpcEndpointConnectionsError {}
impl RejectVpcEndpointConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RejectVpcEndpointConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RejectVpcEndpointConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RejectVpcEndpointConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RejectVpcPeeringConnectionError {}
impl RejectVpcPeeringConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RejectVpcPeeringConnectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RejectVpcPeeringConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RejectVpcPeeringConnectionError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReleaseAddressError {}
impl ReleaseAddressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReleaseAddressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReleaseAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReleaseAddressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReleaseHostsError {}
impl ReleaseHostsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReleaseHostsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReleaseHostsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReleaseHostsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReplaceIamInstanceProfileAssociationError {}
impl ReplaceIamInstanceProfileAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ReplaceIamInstanceProfileAssociationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReplaceIamInstanceProfileAssociationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReplaceIamInstanceProfileAssociationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReplaceNetworkAclAssociationError {}
impl ReplaceNetworkAclAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ReplaceNetworkAclAssociationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReplaceNetworkAclAssociationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReplaceNetworkAclAssociationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReplaceNetworkAclEntryError {}
impl ReplaceNetworkAclEntryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReplaceNetworkAclEntryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReplaceNetworkAclEntryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReplaceNetworkAclEntryError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReplaceRouteError {}
impl ReplaceRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReplaceRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReplaceRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReplaceRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReplaceRouteTableAssociationError {}
impl ReplaceRouteTableAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ReplaceRouteTableAssociationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReplaceRouteTableAssociationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReplaceRouteTableAssociationError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReplaceTransitGatewayRouteError {}
impl ReplaceTransitGatewayRouteError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ReplaceTransitGatewayRouteError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReplaceTransitGatewayRouteError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReplaceTransitGatewayRouteError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ReportInstanceStatusError {}
impl ReportInstanceStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReportInstanceStatusError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ReportInstanceStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReportInstanceStatusError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RequestSpotFleetError {}
impl RequestSpotFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RequestSpotFleetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RequestSpotFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RequestSpotFleetError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RequestSpotInstancesError {}
impl RequestSpotInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RequestSpotInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RequestSpotInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RequestSpotInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetEbsDefaultKmsKeyIdError {}
impl ResetEbsDefaultKmsKeyIdError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetEbsDefaultKmsKeyIdError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetEbsDefaultKmsKeyIdError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetEbsDefaultKmsKeyIdError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetFpgaImageAttributeError {}
impl ResetFpgaImageAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetFpgaImageAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetFpgaImageAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetFpgaImageAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetImageAttributeError {}
impl ResetImageAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetImageAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetImageAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetImageAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetInstanceAttributeError {}
impl ResetInstanceAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetInstanceAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetInstanceAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetInstanceAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetNetworkInterfaceAttributeError {}
impl ResetNetworkInterfaceAttributeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ResetNetworkInterfaceAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetNetworkInterfaceAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetNetworkInterfaceAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetSnapshotAttributeError {}
impl ResetSnapshotAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetSnapshotAttributeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetSnapshotAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetSnapshotAttributeError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RestoreAddressToClassicError {}
impl RestoreAddressToClassicError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RestoreAddressToClassicError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RestoreAddressToClassicError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RestoreAddressToClassicError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RevokeClientVpnIngressError {}
impl RevokeClientVpnIngressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokeClientVpnIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RevokeClientVpnIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RevokeClientVpnIngressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RevokeSecurityGroupEgressError {}
impl RevokeSecurityGroupEgressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokeSecurityGroupEgressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RevokeSecurityGroupEgressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RevokeSecurityGroupEgressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RevokeSecurityGroupIngressError {}
impl RevokeSecurityGroupIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RevokeSecurityGroupIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RevokeSecurityGroupIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RevokeSecurityGroupIngressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RunInstancesError {}
impl RunInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RunInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RunInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RunInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum RunScheduledInstancesError {}
impl RunScheduledInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RunScheduledInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RunScheduledInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RunScheduledInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum SearchTransitGatewayRoutesError {}
impl SearchTransitGatewayRoutesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<SearchTransitGatewayRoutesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for SearchTransitGatewayRoutesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SearchTransitGatewayRoutesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum StartInstancesError {}
impl StartInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for StartInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum StopInstancesError {}
impl StopInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for StopInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum TerminateClientVpnConnectionsError {}
impl TerminateClientVpnConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<TerminateClientVpnConnectionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for TerminateClientVpnConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TerminateClientVpnConnectionsError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum TerminateInstancesError {}
impl TerminateInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TerminateInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for TerminateInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TerminateInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum UnassignIpv6AddressesError {}
impl UnassignIpv6AddressesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnassignIpv6AddressesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UnassignIpv6AddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UnassignIpv6AddressesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum UnassignPrivateIpAddressesError {}
impl UnassignPrivateIpAddressesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UnassignPrivateIpAddressesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UnassignPrivateIpAddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UnassignPrivateIpAddressesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum UnmonitorInstancesError {}
impl UnmonitorInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnmonitorInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UnmonitorInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UnmonitorInstancesError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateSecurityGroupRuleDescriptionsEgressError {}
impl UpdateSecurityGroupRuleDescriptionsEgressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateSecurityGroupRuleDescriptionsEgressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateSecurityGroupRuleDescriptionsEgressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateSecurityGroupRuleDescriptionsEgressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateSecurityGroupRuleDescriptionsIngressError {}
impl UpdateSecurityGroupRuleDescriptionsIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateSecurityGroupRuleDescriptionsIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateSecurityGroupRuleDescriptionsIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateSecurityGroupRuleDescriptionsIngressError {
fn description(&self) -> &str {
match *self {}
}
}
#[derive(Debug, PartialEq)]
pub enum WithdrawByoipCidrError {}
impl WithdrawByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<WithdrawByoipCidrError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("Response", stack)?;
start_element("Errors", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for WithdrawByoipCidrError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for WithdrawByoipCidrError {
fn description(&self) -> &str {
match *self {}
}
}
pub trait Ec2 {
fn accept_reserved_instances_exchange_quote(
&self,
input: AcceptReservedInstancesExchangeQuoteRequest,
) -> RusotoFuture<
AcceptReservedInstancesExchangeQuoteResult,
AcceptReservedInstancesExchangeQuoteError,
>;
fn accept_transit_gateway_vpc_attachment(
&self,
input: AcceptTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<AcceptTransitGatewayVpcAttachmentResult, AcceptTransitGatewayVpcAttachmentError>;
fn accept_vpc_endpoint_connections(
&self,
input: AcceptVpcEndpointConnectionsRequest,
) -> RusotoFuture<AcceptVpcEndpointConnectionsResult, AcceptVpcEndpointConnectionsError>;
fn accept_vpc_peering_connection(
&self,
input: AcceptVpcPeeringConnectionRequest,
) -> RusotoFuture<AcceptVpcPeeringConnectionResult, AcceptVpcPeeringConnectionError>;
fn advertise_byoip_cidr(
&self,
input: AdvertiseByoipCidrRequest,
) -> RusotoFuture<AdvertiseByoipCidrResult, AdvertiseByoipCidrError>;
fn allocate_address(
&self,
input: AllocateAddressRequest,
) -> RusotoFuture<AllocateAddressResult, AllocateAddressError>;
fn allocate_hosts(
&self,
input: AllocateHostsRequest,
) -> RusotoFuture<AllocateHostsResult, AllocateHostsError>;
fn apply_security_groups_to_client_vpn_target_network(
&self,
input: ApplySecurityGroupsToClientVpnTargetNetworkRequest,
) -> RusotoFuture<
ApplySecurityGroupsToClientVpnTargetNetworkResult,
ApplySecurityGroupsToClientVpnTargetNetworkError,
>;
fn assign_ipv_6_addresses(
&self,
input: AssignIpv6AddressesRequest,
) -> RusotoFuture<AssignIpv6AddressesResult, AssignIpv6AddressesError>;
fn assign_private_ip_addresses(
&self,
input: AssignPrivateIpAddressesRequest,
) -> RusotoFuture<(), AssignPrivateIpAddressesError>;
fn associate_address(
&self,
input: AssociateAddressRequest,
) -> RusotoFuture<AssociateAddressResult, AssociateAddressError>;
fn associate_client_vpn_target_network(
&self,
input: AssociateClientVpnTargetNetworkRequest,
) -> RusotoFuture<AssociateClientVpnTargetNetworkResult, AssociateClientVpnTargetNetworkError>;
fn associate_dhcp_options(
&self,
input: AssociateDhcpOptionsRequest,
) -> RusotoFuture<(), AssociateDhcpOptionsError>;
fn associate_iam_instance_profile(
&self,
input: AssociateIamInstanceProfileRequest,
) -> RusotoFuture<AssociateIamInstanceProfileResult, AssociateIamInstanceProfileError>;
fn associate_route_table(
&self,
input: AssociateRouteTableRequest,
) -> RusotoFuture<AssociateRouteTableResult, AssociateRouteTableError>;
fn associate_subnet_cidr_block(
&self,
input: AssociateSubnetCidrBlockRequest,
) -> RusotoFuture<AssociateSubnetCidrBlockResult, AssociateSubnetCidrBlockError>;
fn associate_transit_gateway_route_table(
&self,
input: AssociateTransitGatewayRouteTableRequest,
) -> RusotoFuture<AssociateTransitGatewayRouteTableResult, AssociateTransitGatewayRouteTableError>;
fn associate_vpc_cidr_block(
&self,
input: AssociateVpcCidrBlockRequest,
) -> RusotoFuture<AssociateVpcCidrBlockResult, AssociateVpcCidrBlockError>;
fn attach_classic_link_vpc(
&self,
input: AttachClassicLinkVpcRequest,
) -> RusotoFuture<AttachClassicLinkVpcResult, AttachClassicLinkVpcError>;
fn attach_internet_gateway(
&self,
input: AttachInternetGatewayRequest,
) -> RusotoFuture<(), AttachInternetGatewayError>;
fn attach_network_interface(
&self,
input: AttachNetworkInterfaceRequest,
) -> RusotoFuture<AttachNetworkInterfaceResult, AttachNetworkInterfaceError>;
fn attach_volume(
&self,
input: AttachVolumeRequest,
) -> RusotoFuture<VolumeAttachment, AttachVolumeError>;
fn attach_vpn_gateway(
&self,
input: AttachVpnGatewayRequest,
) -> RusotoFuture<AttachVpnGatewayResult, AttachVpnGatewayError>;
fn authorize_client_vpn_ingress(
&self,
input: AuthorizeClientVpnIngressRequest,
) -> RusotoFuture<AuthorizeClientVpnIngressResult, AuthorizeClientVpnIngressError>;
fn authorize_security_group_egress(
&self,
input: AuthorizeSecurityGroupEgressRequest,
) -> RusotoFuture<(), AuthorizeSecurityGroupEgressError>;
fn authorize_security_group_ingress(
&self,
input: AuthorizeSecurityGroupIngressRequest,
) -> RusotoFuture<(), AuthorizeSecurityGroupIngressError>;
fn bundle_instance(
&self,
input: BundleInstanceRequest,
) -> RusotoFuture<BundleInstanceResult, BundleInstanceError>;
fn cancel_bundle_task(
&self,
input: CancelBundleTaskRequest,
) -> RusotoFuture<CancelBundleTaskResult, CancelBundleTaskError>;
fn cancel_capacity_reservation(
&self,
input: CancelCapacityReservationRequest,
) -> RusotoFuture<CancelCapacityReservationResult, CancelCapacityReservationError>;
fn cancel_conversion_task(
&self,
input: CancelConversionRequest,
) -> RusotoFuture<(), CancelConversionTaskError>;
fn cancel_export_task(
&self,
input: CancelExportTaskRequest,
) -> RusotoFuture<(), CancelExportTaskError>;
fn cancel_import_task(
&self,
input: CancelImportTaskRequest,
) -> RusotoFuture<CancelImportTaskResult, CancelImportTaskError>;
fn cancel_reserved_instances_listing(
&self,
input: CancelReservedInstancesListingRequest,
) -> RusotoFuture<CancelReservedInstancesListingResult, CancelReservedInstancesListingError>;
fn cancel_spot_fleet_requests(
&self,
input: CancelSpotFleetRequestsRequest,
) -> RusotoFuture<CancelSpotFleetRequestsResponse, EC2CancelSpotFleetRequestsError>;
fn cancel_spot_instance_requests(
&self,
input: CancelSpotInstanceRequestsRequest,
) -> RusotoFuture<CancelSpotInstanceRequestsResult, CancelSpotInstanceRequestsError>;
fn confirm_product_instance(
&self,
input: ConfirmProductInstanceRequest,
) -> RusotoFuture<ConfirmProductInstanceResult, ConfirmProductInstanceError>;
fn copy_fpga_image(
&self,
input: CopyFpgaImageRequest,
) -> RusotoFuture<CopyFpgaImageResult, CopyFpgaImageError>;
fn copy_image(&self, input: CopyImageRequest) -> RusotoFuture<CopyImageResult, CopyImageError>;
fn copy_snapshot(
&self,
input: CopySnapshotRequest,
) -> RusotoFuture<CopySnapshotResult, CopySnapshotError>;
fn create_capacity_reservation(
&self,
input: CreateCapacityReservationRequest,
) -> RusotoFuture<CreateCapacityReservationResult, CreateCapacityReservationError>;
fn create_client_vpn_endpoint(
&self,
input: CreateClientVpnEndpointRequest,
) -> RusotoFuture<CreateClientVpnEndpointResult, CreateClientVpnEndpointError>;
fn create_client_vpn_route(
&self,
input: CreateClientVpnRouteRequest,
) -> RusotoFuture<CreateClientVpnRouteResult, CreateClientVpnRouteError>;
fn create_customer_gateway(
&self,
input: CreateCustomerGatewayRequest,
) -> RusotoFuture<CreateCustomerGatewayResult, CreateCustomerGatewayError>;
fn create_default_subnet(
&self,
input: CreateDefaultSubnetRequest,
) -> RusotoFuture<CreateDefaultSubnetResult, CreateDefaultSubnetError>;
fn create_default_vpc(
&self,
input: CreateDefaultVpcRequest,
) -> RusotoFuture<CreateDefaultVpcResult, CreateDefaultVpcError>;
fn create_dhcp_options(
&self,
input: CreateDhcpOptionsRequest,
) -> RusotoFuture<CreateDhcpOptionsResult, CreateDhcpOptionsError>;
fn create_egress_only_internet_gateway(
&self,
input: CreateEgressOnlyInternetGatewayRequest,
) -> RusotoFuture<CreateEgressOnlyInternetGatewayResult, CreateEgressOnlyInternetGatewayError>;
fn create_fleet(
&self,
input: CreateFleetRequest,
) -> RusotoFuture<CreateFleetResult, CreateFleetError>;
fn create_flow_logs(
&self,
input: CreateFlowLogsRequest,
) -> RusotoFuture<CreateFlowLogsResult, CreateFlowLogsError>;
fn create_fpga_image(
&self,
input: CreateFpgaImageRequest,
) -> RusotoFuture<CreateFpgaImageResult, CreateFpgaImageError>;
fn create_image(
&self,
input: CreateImageRequest,
) -> RusotoFuture<CreateImageResult, CreateImageError>;
fn create_instance_export_task(
&self,
input: CreateInstanceExportTaskRequest,
) -> RusotoFuture<CreateInstanceExportTaskResult, CreateInstanceExportTaskError>;
fn create_internet_gateway(
&self,
input: CreateInternetGatewayRequest,
) -> RusotoFuture<CreateInternetGatewayResult, CreateInternetGatewayError>;
fn create_key_pair(
&self,
input: CreateKeyPairRequest,
) -> RusotoFuture<KeyPair, CreateKeyPairError>;
fn create_launch_template(
&self,
input: CreateLaunchTemplateRequest,
) -> RusotoFuture<CreateLaunchTemplateResult, CreateLaunchTemplateError>;
fn create_launch_template_version(
&self,
input: CreateLaunchTemplateVersionRequest,
) -> RusotoFuture<CreateLaunchTemplateVersionResult, CreateLaunchTemplateVersionError>;
fn create_nat_gateway(
&self,
input: CreateNatGatewayRequest,
) -> RusotoFuture<CreateNatGatewayResult, CreateNatGatewayError>;
fn create_network_acl(
&self,
input: CreateNetworkAclRequest,
) -> RusotoFuture<CreateNetworkAclResult, CreateNetworkAclError>;
fn create_network_acl_entry(
&self,
input: CreateNetworkAclEntryRequest,
) -> RusotoFuture<(), CreateNetworkAclEntryError>;
fn create_network_interface(
&self,
input: CreateNetworkInterfaceRequest,
) -> RusotoFuture<CreateNetworkInterfaceResult, CreateNetworkInterfaceError>;
fn create_network_interface_permission(
&self,
input: CreateNetworkInterfacePermissionRequest,
) -> RusotoFuture<CreateNetworkInterfacePermissionResult, CreateNetworkInterfacePermissionError>;
fn create_placement_group(
&self,
input: CreatePlacementGroupRequest,
) -> RusotoFuture<(), CreatePlacementGroupError>;
fn create_reserved_instances_listing(
&self,
input: CreateReservedInstancesListingRequest,
) -> RusotoFuture<CreateReservedInstancesListingResult, CreateReservedInstancesListingError>;
fn create_route(
&self,
input: CreateRouteRequest,
) -> RusotoFuture<CreateRouteResult, CreateRouteError>;
fn create_route_table(
&self,
input: CreateRouteTableRequest,
) -> RusotoFuture<CreateRouteTableResult, CreateRouteTableError>;
fn create_security_group(
&self,
input: CreateSecurityGroupRequest,
) -> RusotoFuture<CreateSecurityGroupResult, CreateSecurityGroupError>;
fn create_snapshot(
&self,
input: CreateSnapshotRequest,
) -> RusotoFuture<Snapshot, CreateSnapshotError>;
fn create_snapshots(
&self,
input: CreateSnapshotsRequest,
) -> RusotoFuture<CreateSnapshotsResult, CreateSnapshotsError>;
fn create_spot_datafeed_subscription(
&self,
input: CreateSpotDatafeedSubscriptionRequest,
) -> RusotoFuture<CreateSpotDatafeedSubscriptionResult, CreateSpotDatafeedSubscriptionError>;
fn create_subnet(
&self,
input: CreateSubnetRequest,
) -> RusotoFuture<CreateSubnetResult, CreateSubnetError>;
fn create_tags(&self, input: CreateTagsRequest) -> RusotoFuture<(), CreateTagsError>;
fn create_transit_gateway(
&self,
input: CreateTransitGatewayRequest,
) -> RusotoFuture<CreateTransitGatewayResult, CreateTransitGatewayError>;
fn create_transit_gateway_route(
&self,
input: CreateTransitGatewayRouteRequest,
) -> RusotoFuture<CreateTransitGatewayRouteResult, CreateTransitGatewayRouteError>;
fn create_transit_gateway_route_table(
&self,
input: CreateTransitGatewayRouteTableRequest,
) -> RusotoFuture<CreateTransitGatewayRouteTableResult, CreateTransitGatewayRouteTableError>;
fn create_transit_gateway_vpc_attachment(
&self,
input: CreateTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<CreateTransitGatewayVpcAttachmentResult, CreateTransitGatewayVpcAttachmentError>;
fn create_volume(&self, input: CreateVolumeRequest) -> RusotoFuture<Volume, CreateVolumeError>;
fn create_vpc(&self, input: CreateVpcRequest) -> RusotoFuture<CreateVpcResult, CreateVpcError>;
fn create_vpc_endpoint(
&self,
input: CreateVpcEndpointRequest,
) -> RusotoFuture<CreateVpcEndpointResult, CreateVpcEndpointError>;
fn create_vpc_endpoint_connection_notification(
&self,
input: CreateVpcEndpointConnectionNotificationRequest,
) -> RusotoFuture<
CreateVpcEndpointConnectionNotificationResult,
CreateVpcEndpointConnectionNotificationError,
>;
fn create_vpc_endpoint_service_configuration(
&self,
input: CreateVpcEndpointServiceConfigurationRequest,
) -> RusotoFuture<
CreateVpcEndpointServiceConfigurationResult,
CreateVpcEndpointServiceConfigurationError,
>;
fn create_vpc_peering_connection(
&self,
input: CreateVpcPeeringConnectionRequest,
) -> RusotoFuture<CreateVpcPeeringConnectionResult, CreateVpcPeeringConnectionError>;
fn create_vpn_connection(
&self,
input: CreateVpnConnectionRequest,
) -> RusotoFuture<CreateVpnConnectionResult, CreateVpnConnectionError>;
fn create_vpn_connection_route(
&self,
input: CreateVpnConnectionRouteRequest,
) -> RusotoFuture<(), CreateVpnConnectionRouteError>;
fn create_vpn_gateway(
&self,
input: CreateVpnGatewayRequest,
) -> RusotoFuture<CreateVpnGatewayResult, CreateVpnGatewayError>;
fn delete_client_vpn_endpoint(
&self,
input: DeleteClientVpnEndpointRequest,
) -> RusotoFuture<DeleteClientVpnEndpointResult, DeleteClientVpnEndpointError>;
fn delete_client_vpn_route(
&self,
input: DeleteClientVpnRouteRequest,
) -> RusotoFuture<DeleteClientVpnRouteResult, DeleteClientVpnRouteError>;
fn delete_customer_gateway(
&self,
input: DeleteCustomerGatewayRequest,
) -> RusotoFuture<(), DeleteCustomerGatewayError>;
fn delete_dhcp_options(
&self,
input: DeleteDhcpOptionsRequest,
) -> RusotoFuture<(), DeleteDhcpOptionsError>;
fn delete_egress_only_internet_gateway(
&self,
input: DeleteEgressOnlyInternetGatewayRequest,
) -> RusotoFuture<DeleteEgressOnlyInternetGatewayResult, DeleteEgressOnlyInternetGatewayError>;
fn delete_fleets(
&self,
input: DeleteFleetsRequest,
) -> RusotoFuture<DeleteFleetsResult, DeleteFleetsError>;
fn delete_flow_logs(
&self,
input: DeleteFlowLogsRequest,
) -> RusotoFuture<DeleteFlowLogsResult, DeleteFlowLogsError>;
fn delete_fpga_image(
&self,
input: DeleteFpgaImageRequest,
) -> RusotoFuture<DeleteFpgaImageResult, DeleteFpgaImageError>;
fn delete_internet_gateway(
&self,
input: DeleteInternetGatewayRequest,
) -> RusotoFuture<(), DeleteInternetGatewayError>;
fn delete_key_pair(&self, input: DeleteKeyPairRequest) -> RusotoFuture<(), DeleteKeyPairError>;
fn delete_launch_template(
&self,
input: DeleteLaunchTemplateRequest,
) -> RusotoFuture<DeleteLaunchTemplateResult, DeleteLaunchTemplateError>;
fn delete_launch_template_versions(
&self,
input: DeleteLaunchTemplateVersionsRequest,
) -> RusotoFuture<DeleteLaunchTemplateVersionsResult, DeleteLaunchTemplateVersionsError>;
fn delete_nat_gateway(
&self,
input: DeleteNatGatewayRequest,
) -> RusotoFuture<DeleteNatGatewayResult, DeleteNatGatewayError>;
fn delete_network_acl(
&self,
input: DeleteNetworkAclRequest,
) -> RusotoFuture<(), DeleteNetworkAclError>;
fn delete_network_acl_entry(
&self,
input: DeleteNetworkAclEntryRequest,
) -> RusotoFuture<(), DeleteNetworkAclEntryError>;
fn delete_network_interface(
&self,
input: DeleteNetworkInterfaceRequest,
) -> RusotoFuture<(), DeleteNetworkInterfaceError>;
fn delete_network_interface_permission(
&self,
input: DeleteNetworkInterfacePermissionRequest,
) -> RusotoFuture<DeleteNetworkInterfacePermissionResult, DeleteNetworkInterfacePermissionError>;
fn delete_placement_group(
&self,
input: DeletePlacementGroupRequest,
) -> RusotoFuture<(), DeletePlacementGroupError>;
fn delete_route(&self, input: DeleteRouteRequest) -> RusotoFuture<(), DeleteRouteError>;
fn delete_route_table(
&self,
input: DeleteRouteTableRequest,
) -> RusotoFuture<(), DeleteRouteTableError>;
fn delete_security_group(
&self,
input: DeleteSecurityGroupRequest,
) -> RusotoFuture<(), DeleteSecurityGroupError>;
fn delete_snapshot(
&self,
input: DeleteSnapshotRequest,
) -> RusotoFuture<(), DeleteSnapshotError>;
fn delete_spot_datafeed_subscription(
&self,
input: DeleteSpotDatafeedSubscriptionRequest,
) -> RusotoFuture<(), DeleteSpotDatafeedSubscriptionError>;
fn delete_subnet(&self, input: DeleteSubnetRequest) -> RusotoFuture<(), DeleteSubnetError>;
fn delete_tags(&self, input: DeleteTagsRequest) -> RusotoFuture<(), DeleteTagsError>;
fn delete_transit_gateway(
&self,
input: DeleteTransitGatewayRequest,
) -> RusotoFuture<DeleteTransitGatewayResult, DeleteTransitGatewayError>;
fn delete_transit_gateway_route(
&self,
input: DeleteTransitGatewayRouteRequest,
) -> RusotoFuture<DeleteTransitGatewayRouteResult, DeleteTransitGatewayRouteError>;
fn delete_transit_gateway_route_table(
&self,
input: DeleteTransitGatewayRouteTableRequest,
) -> RusotoFuture<DeleteTransitGatewayRouteTableResult, DeleteTransitGatewayRouteTableError>;
fn delete_transit_gateway_vpc_attachment(
&self,
input: DeleteTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<DeleteTransitGatewayVpcAttachmentResult, DeleteTransitGatewayVpcAttachmentError>;
fn delete_volume(&self, input: DeleteVolumeRequest) -> RusotoFuture<(), DeleteVolumeError>;
fn delete_vpc(&self, input: DeleteVpcRequest) -> RusotoFuture<(), DeleteVpcError>;
fn delete_vpc_endpoint_connection_notifications(
&self,
input: DeleteVpcEndpointConnectionNotificationsRequest,
) -> RusotoFuture<
DeleteVpcEndpointConnectionNotificationsResult,
DeleteVpcEndpointConnectionNotificationsError,
>;
fn delete_vpc_endpoint_service_configurations(
&self,
input: DeleteVpcEndpointServiceConfigurationsRequest,
) -> RusotoFuture<
DeleteVpcEndpointServiceConfigurationsResult,
DeleteVpcEndpointServiceConfigurationsError,
>;
fn delete_vpc_endpoints(
&self,
input: DeleteVpcEndpointsRequest,
) -> RusotoFuture<DeleteVpcEndpointsResult, DeleteVpcEndpointsError>;
fn delete_vpc_peering_connection(
&self,
input: DeleteVpcPeeringConnectionRequest,
) -> RusotoFuture<DeleteVpcPeeringConnectionResult, DeleteVpcPeeringConnectionError>;
fn delete_vpn_connection(
&self,
input: DeleteVpnConnectionRequest,
) -> RusotoFuture<(), DeleteVpnConnectionError>;
fn delete_vpn_connection_route(
&self,
input: DeleteVpnConnectionRouteRequest,
) -> RusotoFuture<(), DeleteVpnConnectionRouteError>;
fn delete_vpn_gateway(
&self,
input: DeleteVpnGatewayRequest,
) -> RusotoFuture<(), DeleteVpnGatewayError>;
fn deprovision_byoip_cidr(
&self,
input: DeprovisionByoipCidrRequest,
) -> RusotoFuture<DeprovisionByoipCidrResult, DeprovisionByoipCidrError>;
fn deregister_image(
&self,
input: DeregisterImageRequest,
) -> RusotoFuture<(), DeregisterImageError>;
fn describe_account_attributes(
&self,
input: DescribeAccountAttributesRequest,
) -> RusotoFuture<DescribeAccountAttributesResult, DescribeAccountAttributesError>;
fn describe_addresses(
&self,
input: DescribeAddressesRequest,
) -> RusotoFuture<DescribeAddressesResult, DescribeAddressesError>;
fn describe_aggregate_id_format(
&self,
input: DescribeAggregateIdFormatRequest,
) -> RusotoFuture<DescribeAggregateIdFormatResult, DescribeAggregateIdFormatError>;
fn describe_availability_zones(
&self,
input: DescribeAvailabilityZonesRequest,
) -> RusotoFuture<DescribeAvailabilityZonesResult, DescribeAvailabilityZonesError>;
fn describe_bundle_tasks(
&self,
input: DescribeBundleTasksRequest,
) -> RusotoFuture<DescribeBundleTasksResult, DescribeBundleTasksError>;
fn describe_byoip_cidrs(
&self,
input: DescribeByoipCidrsRequest,
) -> RusotoFuture<DescribeByoipCidrsResult, DescribeByoipCidrsError>;
fn describe_capacity_reservations(
&self,
input: DescribeCapacityReservationsRequest,
) -> RusotoFuture<DescribeCapacityReservationsResult, DescribeCapacityReservationsError>;
fn describe_classic_link_instances(
&self,
input: DescribeClassicLinkInstancesRequest,
) -> RusotoFuture<DescribeClassicLinkInstancesResult, DescribeClassicLinkInstancesError>;
fn describe_client_vpn_authorization_rules(
&self,
input: DescribeClientVpnAuthorizationRulesRequest,
) -> RusotoFuture<
DescribeClientVpnAuthorizationRulesResult,
DescribeClientVpnAuthorizationRulesError,
>;
fn describe_client_vpn_connections(
&self,
input: DescribeClientVpnConnectionsRequest,
) -> RusotoFuture<DescribeClientVpnConnectionsResult, DescribeClientVpnConnectionsError>;
fn describe_client_vpn_endpoints(
&self,
input: DescribeClientVpnEndpointsRequest,
) -> RusotoFuture<DescribeClientVpnEndpointsResult, DescribeClientVpnEndpointsError>;
fn describe_client_vpn_routes(
&self,
input: DescribeClientVpnRoutesRequest,
) -> RusotoFuture<DescribeClientVpnRoutesResult, DescribeClientVpnRoutesError>;
fn describe_client_vpn_target_networks(
&self,
input: DescribeClientVpnTargetNetworksRequest,
) -> RusotoFuture<DescribeClientVpnTargetNetworksResult, DescribeClientVpnTargetNetworksError>;
fn describe_conversion_tasks(
&self,
input: DescribeConversionTasksRequest,
) -> RusotoFuture<DescribeConversionTasksResult, DescribeConversionTasksError>;
fn describe_customer_gateways(
&self,
input: DescribeCustomerGatewaysRequest,
) -> RusotoFuture<DescribeCustomerGatewaysResult, DescribeCustomerGatewaysError>;
fn describe_dhcp_options(
&self,
input: DescribeDhcpOptionsRequest,
) -> RusotoFuture<DescribeDhcpOptionsResult, DescribeDhcpOptionsError>;
fn describe_egress_only_internet_gateways(
&self,
input: DescribeEgressOnlyInternetGatewaysRequest,
) -> RusotoFuture<
DescribeEgressOnlyInternetGatewaysResult,
DescribeEgressOnlyInternetGatewaysError,
>;
fn describe_elastic_gpus(
&self,
input: DescribeElasticGpusRequest,
) -> RusotoFuture<DescribeElasticGpusResult, DescribeElasticGpusError>;
fn describe_export_tasks(
&self,
input: DescribeExportTasksRequest,
) -> RusotoFuture<DescribeExportTasksResult, DescribeExportTasksError>;
fn describe_fleet_history(
&self,
input: DescribeFleetHistoryRequest,
) -> RusotoFuture<DescribeFleetHistoryResult, DescribeFleetHistoryError>;
fn describe_fleet_instances(
&self,
input: DescribeFleetInstancesRequest,
) -> RusotoFuture<DescribeFleetInstancesResult, DescribeFleetInstancesError>;
fn describe_fleets(
&self,
input: DescribeFleetsRequest,
) -> RusotoFuture<DescribeFleetsResult, DescribeFleetsError>;
fn describe_flow_logs(
&self,
input: DescribeFlowLogsRequest,
) -> RusotoFuture<DescribeFlowLogsResult, DescribeFlowLogsError>;
fn describe_fpga_image_attribute(
&self,
input: DescribeFpgaImageAttributeRequest,
) -> RusotoFuture<DescribeFpgaImageAttributeResult, DescribeFpgaImageAttributeError>;
fn describe_fpga_images(
&self,
input: DescribeFpgaImagesRequest,
) -> RusotoFuture<DescribeFpgaImagesResult, DescribeFpgaImagesError>;
fn describe_host_reservation_offerings(
&self,
input: DescribeHostReservationOfferingsRequest,
) -> RusotoFuture<DescribeHostReservationOfferingsResult, DescribeHostReservationOfferingsError>;
fn describe_host_reservations(
&self,
input: DescribeHostReservationsRequest,
) -> RusotoFuture<DescribeHostReservationsResult, DescribeHostReservationsError>;
fn describe_hosts(
&self,
input: DescribeHostsRequest,
) -> RusotoFuture<DescribeHostsResult, DescribeHostsError>;
fn describe_iam_instance_profile_associations(
&self,
input: DescribeIamInstanceProfileAssociationsRequest,
) -> RusotoFuture<
DescribeIamInstanceProfileAssociationsResult,
DescribeIamInstanceProfileAssociationsError,
>;
fn describe_id_format(
&self,
input: DescribeIdFormatRequest,
) -> RusotoFuture<DescribeIdFormatResult, DescribeIdFormatError>;
fn describe_identity_id_format(
&self,
input: DescribeIdentityIdFormatRequest,
) -> RusotoFuture<DescribeIdentityIdFormatResult, DescribeIdentityIdFormatError>;
fn describe_image_attribute(
&self,
input: DescribeImageAttributeRequest,
) -> RusotoFuture<ImageAttribute, DescribeImageAttributeError>;
fn describe_images(
&self,
input: DescribeImagesRequest,
) -> RusotoFuture<DescribeImagesResult, DescribeImagesError>;
fn describe_import_image_tasks(
&self,
input: DescribeImportImageTasksRequest,
) -> RusotoFuture<DescribeImportImageTasksResult, DescribeImportImageTasksError>;
fn describe_import_snapshot_tasks(
&self,
input: DescribeImportSnapshotTasksRequest,
) -> RusotoFuture<DescribeImportSnapshotTasksResult, DescribeImportSnapshotTasksError>;
fn describe_instance_attribute(
&self,
input: DescribeInstanceAttributeRequest,
) -> RusotoFuture<InstanceAttribute, DescribeInstanceAttributeError>;
fn describe_instance_credit_specifications(
&self,
input: DescribeInstanceCreditSpecificationsRequest,
) -> RusotoFuture<
DescribeInstanceCreditSpecificationsResult,
DescribeInstanceCreditSpecificationsError,
>;
fn describe_instance_status(
&self,
input: DescribeInstanceStatusRequest,
) -> RusotoFuture<DescribeInstanceStatusResult, DescribeInstanceStatusError>;
fn describe_instances(
&self,
input: DescribeInstancesRequest,
) -> RusotoFuture<DescribeInstancesResult, DescribeInstancesError>;
fn describe_internet_gateways(
&self,
input: DescribeInternetGatewaysRequest,
) -> RusotoFuture<DescribeInternetGatewaysResult, DescribeInternetGatewaysError>;
fn describe_key_pairs(
&self,
input: DescribeKeyPairsRequest,
) -> RusotoFuture<DescribeKeyPairsResult, DescribeKeyPairsError>;
fn describe_launch_template_versions(
&self,
input: DescribeLaunchTemplateVersionsRequest,
) -> RusotoFuture<DescribeLaunchTemplateVersionsResult, DescribeLaunchTemplateVersionsError>;
fn describe_launch_templates(
&self,
input: DescribeLaunchTemplatesRequest,
) -> RusotoFuture<DescribeLaunchTemplatesResult, DescribeLaunchTemplatesError>;
fn describe_moving_addresses(
&self,
input: DescribeMovingAddressesRequest,
) -> RusotoFuture<DescribeMovingAddressesResult, DescribeMovingAddressesError>;
fn describe_nat_gateways(
&self,
input: DescribeNatGatewaysRequest,
) -> RusotoFuture<DescribeNatGatewaysResult, DescribeNatGatewaysError>;
fn describe_network_acls(
&self,
input: DescribeNetworkAclsRequest,
) -> RusotoFuture<DescribeNetworkAclsResult, DescribeNetworkAclsError>;
fn describe_network_interface_attribute(
&self,
input: DescribeNetworkInterfaceAttributeRequest,
) -> RusotoFuture<DescribeNetworkInterfaceAttributeResult, DescribeNetworkInterfaceAttributeError>;
fn describe_network_interface_permissions(
&self,
input: DescribeNetworkInterfacePermissionsRequest,
) -> RusotoFuture<
DescribeNetworkInterfacePermissionsResult,
DescribeNetworkInterfacePermissionsError,
>;
fn describe_network_interfaces(
&self,
input: DescribeNetworkInterfacesRequest,
) -> RusotoFuture<DescribeNetworkInterfacesResult, DescribeNetworkInterfacesError>;
fn describe_placement_groups(
&self,
input: DescribePlacementGroupsRequest,
) -> RusotoFuture<DescribePlacementGroupsResult, DescribePlacementGroupsError>;
fn describe_prefix_lists(
&self,
input: DescribePrefixListsRequest,
) -> RusotoFuture<DescribePrefixListsResult, DescribePrefixListsError>;
fn describe_principal_id_format(
&self,
input: DescribePrincipalIdFormatRequest,
) -> RusotoFuture<DescribePrincipalIdFormatResult, DescribePrincipalIdFormatError>;
fn describe_public_ipv_4_pools(
&self,
input: DescribePublicIpv4PoolsRequest,
) -> RusotoFuture<DescribePublicIpv4PoolsResult, DescribePublicIpv4PoolsError>;
fn describe_regions(
&self,
input: DescribeRegionsRequest,
) -> RusotoFuture<DescribeRegionsResult, DescribeRegionsError>;
fn describe_reserved_instances(
&self,
input: DescribeReservedInstancesRequest,
) -> RusotoFuture<DescribeReservedInstancesResult, DescribeReservedInstancesError>;
fn describe_reserved_instances_listings(
&self,
input: DescribeReservedInstancesListingsRequest,
) -> RusotoFuture<DescribeReservedInstancesListingsResult, DescribeReservedInstancesListingsError>;
fn describe_reserved_instances_modifications(
&self,
input: DescribeReservedInstancesModificationsRequest,
) -> RusotoFuture<
DescribeReservedInstancesModificationsResult,
DescribeReservedInstancesModificationsError,
>;
fn describe_reserved_instances_offerings(
&self,
input: DescribeReservedInstancesOfferingsRequest,
) -> RusotoFuture<
DescribeReservedInstancesOfferingsResult,
DescribeReservedInstancesOfferingsError,
>;
fn describe_route_tables(
&self,
input: DescribeRouteTablesRequest,
) -> RusotoFuture<DescribeRouteTablesResult, DescribeRouteTablesError>;
fn describe_scheduled_instance_availability(
&self,
input: DescribeScheduledInstanceAvailabilityRequest,
) -> RusotoFuture<
DescribeScheduledInstanceAvailabilityResult,
DescribeScheduledInstanceAvailabilityError,
>;
fn describe_scheduled_instances(
&self,
input: DescribeScheduledInstancesRequest,
) -> RusotoFuture<DescribeScheduledInstancesResult, DescribeScheduledInstancesError>;
fn describe_security_group_references(
&self,
input: DescribeSecurityGroupReferencesRequest,
) -> RusotoFuture<DescribeSecurityGroupReferencesResult, DescribeSecurityGroupReferencesError>;
fn describe_security_groups(
&self,
input: DescribeSecurityGroupsRequest,
) -> RusotoFuture<DescribeSecurityGroupsResult, DescribeSecurityGroupsError>;
fn describe_snapshot_attribute(
&self,
input: DescribeSnapshotAttributeRequest,
) -> RusotoFuture<DescribeSnapshotAttributeResult, DescribeSnapshotAttributeError>;
fn describe_snapshots(
&self,
input: DescribeSnapshotsRequest,
) -> RusotoFuture<DescribeSnapshotsResult, DescribeSnapshotsError>;
fn describe_spot_datafeed_subscription(
&self,
input: DescribeSpotDatafeedSubscriptionRequest,
) -> RusotoFuture<DescribeSpotDatafeedSubscriptionResult, DescribeSpotDatafeedSubscriptionError>;
fn describe_spot_fleet_instances(
&self,
input: DescribeSpotFleetInstancesRequest,
) -> RusotoFuture<DescribeSpotFleetInstancesResponse, DescribeSpotFleetInstancesError>;
fn describe_spot_fleet_request_history(
&self,
input: DescribeSpotFleetRequestHistoryRequest,
) -> RusotoFuture<DescribeSpotFleetRequestHistoryResponse, DescribeSpotFleetRequestHistoryError>;
fn describe_spot_fleet_requests(
&self,
input: DescribeSpotFleetRequestsRequest,
) -> RusotoFuture<DescribeSpotFleetRequestsResponse, DescribeSpotFleetRequestsError>;
fn describe_spot_instance_requests(
&self,
input: DescribeSpotInstanceRequestsRequest,
) -> RusotoFuture<DescribeSpotInstanceRequestsResult, DescribeSpotInstanceRequestsError>;
fn describe_spot_price_history(
&self,
input: DescribeSpotPriceHistoryRequest,
) -> RusotoFuture<DescribeSpotPriceHistoryResult, DescribeSpotPriceHistoryError>;
fn describe_stale_security_groups(
&self,
input: DescribeStaleSecurityGroupsRequest,
) -> RusotoFuture<DescribeStaleSecurityGroupsResult, DescribeStaleSecurityGroupsError>;
fn describe_subnets(
&self,
input: DescribeSubnetsRequest,
) -> RusotoFuture<DescribeSubnetsResult, DescribeSubnetsError>;
fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> RusotoFuture<DescribeTagsResult, DescribeTagsError>;
fn describe_transit_gateway_attachments(
&self,
input: DescribeTransitGatewayAttachmentsRequest,
) -> RusotoFuture<DescribeTransitGatewayAttachmentsResult, DescribeTransitGatewayAttachmentsError>;
fn describe_transit_gateway_route_tables(
&self,
input: DescribeTransitGatewayRouteTablesRequest,
) -> RusotoFuture<DescribeTransitGatewayRouteTablesResult, DescribeTransitGatewayRouteTablesError>;
fn describe_transit_gateway_vpc_attachments(
&self,
input: DescribeTransitGatewayVpcAttachmentsRequest,
) -> RusotoFuture<
DescribeTransitGatewayVpcAttachmentsResult,
DescribeTransitGatewayVpcAttachmentsError,
>;
fn describe_transit_gateways(
&self,
input: DescribeTransitGatewaysRequest,
) -> RusotoFuture<DescribeTransitGatewaysResult, DescribeTransitGatewaysError>;
fn describe_volume_attribute(
&self,
input: DescribeVolumeAttributeRequest,
) -> RusotoFuture<DescribeVolumeAttributeResult, DescribeVolumeAttributeError>;
fn describe_volume_status(
&self,
input: DescribeVolumeStatusRequest,
) -> RusotoFuture<DescribeVolumeStatusResult, DescribeVolumeStatusError>;
fn describe_volumes(
&self,
input: DescribeVolumesRequest,
) -> RusotoFuture<DescribeVolumesResult, DescribeVolumesError>;
fn describe_volumes_modifications(
&self,
input: DescribeVolumesModificationsRequest,
) -> RusotoFuture<DescribeVolumesModificationsResult, DescribeVolumesModificationsError>;
fn describe_vpc_attribute(
&self,
input: DescribeVpcAttributeRequest,
) -> RusotoFuture<DescribeVpcAttributeResult, DescribeVpcAttributeError>;
fn describe_vpc_classic_link(
&self,
input: DescribeVpcClassicLinkRequest,
) -> RusotoFuture<DescribeVpcClassicLinkResult, DescribeVpcClassicLinkError>;
fn describe_vpc_classic_link_dns_support(
&self,
input: DescribeVpcClassicLinkDnsSupportRequest,
) -> RusotoFuture<DescribeVpcClassicLinkDnsSupportResult, DescribeVpcClassicLinkDnsSupportError>;
fn describe_vpc_endpoint_connection_notifications(
&self,
input: DescribeVpcEndpointConnectionNotificationsRequest,
) -> RusotoFuture<
DescribeVpcEndpointConnectionNotificationsResult,
DescribeVpcEndpointConnectionNotificationsError,
>;
fn describe_vpc_endpoint_connections(
&self,
input: DescribeVpcEndpointConnectionsRequest,
) -> RusotoFuture<DescribeVpcEndpointConnectionsResult, DescribeVpcEndpointConnectionsError>;
fn describe_vpc_endpoint_service_configurations(
&self,
input: DescribeVpcEndpointServiceConfigurationsRequest,
) -> RusotoFuture<
DescribeVpcEndpointServiceConfigurationsResult,
DescribeVpcEndpointServiceConfigurationsError,
>;
fn describe_vpc_endpoint_service_permissions(
&self,
input: DescribeVpcEndpointServicePermissionsRequest,
) -> RusotoFuture<
DescribeVpcEndpointServicePermissionsResult,
DescribeVpcEndpointServicePermissionsError,
>;
fn describe_vpc_endpoint_services(
&self,
input: DescribeVpcEndpointServicesRequest,
) -> RusotoFuture<DescribeVpcEndpointServicesResult, DescribeVpcEndpointServicesError>;
fn describe_vpc_endpoints(
&self,
input: DescribeVpcEndpointsRequest,
) -> RusotoFuture<DescribeVpcEndpointsResult, DescribeVpcEndpointsError>;
fn describe_vpc_peering_connections(
&self,
input: DescribeVpcPeeringConnectionsRequest,
) -> RusotoFuture<DescribeVpcPeeringConnectionsResult, DescribeVpcPeeringConnectionsError>;
fn describe_vpcs(
&self,
input: DescribeVpcsRequest,
) -> RusotoFuture<DescribeVpcsResult, DescribeVpcsError>;
fn describe_vpn_connections(
&self,
input: DescribeVpnConnectionsRequest,
) -> RusotoFuture<DescribeVpnConnectionsResult, DescribeVpnConnectionsError>;
fn describe_vpn_gateways(
&self,
input: DescribeVpnGatewaysRequest,
) -> RusotoFuture<DescribeVpnGatewaysResult, DescribeVpnGatewaysError>;
fn detach_classic_link_vpc(
&self,
input: DetachClassicLinkVpcRequest,
) -> RusotoFuture<DetachClassicLinkVpcResult, DetachClassicLinkVpcError>;
fn detach_internet_gateway(
&self,
input: DetachInternetGatewayRequest,
) -> RusotoFuture<(), DetachInternetGatewayError>;
fn detach_network_interface(
&self,
input: DetachNetworkInterfaceRequest,
) -> RusotoFuture<(), DetachNetworkInterfaceError>;
fn detach_volume(
&self,
input: DetachVolumeRequest,
) -> RusotoFuture<VolumeAttachment, DetachVolumeError>;
fn detach_vpn_gateway(
&self,
input: DetachVpnGatewayRequest,
) -> RusotoFuture<(), DetachVpnGatewayError>;
fn disable_ebs_encryption_by_default(
&self,
input: DisableEbsEncryptionByDefaultRequest,
) -> RusotoFuture<DisableEbsEncryptionByDefaultResult, DisableEbsEncryptionByDefaultError>;
fn disable_transit_gateway_route_table_propagation(
&self,
input: DisableTransitGatewayRouteTablePropagationRequest,
) -> RusotoFuture<
DisableTransitGatewayRouteTablePropagationResult,
DisableTransitGatewayRouteTablePropagationError,
>;
fn disable_vgw_route_propagation(
&self,
input: DisableVgwRoutePropagationRequest,
) -> RusotoFuture<(), DisableVgwRoutePropagationError>;
fn disable_vpc_classic_link(
&self,
input: DisableVpcClassicLinkRequest,
) -> RusotoFuture<DisableVpcClassicLinkResult, DisableVpcClassicLinkError>;
fn disable_vpc_classic_link_dns_support(
&self,
input: DisableVpcClassicLinkDnsSupportRequest,
) -> RusotoFuture<DisableVpcClassicLinkDnsSupportResult, DisableVpcClassicLinkDnsSupportError>;
fn disassociate_address(
&self,
input: DisassociateAddressRequest,
) -> RusotoFuture<(), DisassociateAddressError>;
fn disassociate_client_vpn_target_network(
&self,
input: DisassociateClientVpnTargetNetworkRequest,
) -> RusotoFuture<
DisassociateClientVpnTargetNetworkResult,
DisassociateClientVpnTargetNetworkError,
>;
fn disassociate_iam_instance_profile(
&self,
input: DisassociateIamInstanceProfileRequest,
) -> RusotoFuture<DisassociateIamInstanceProfileResult, DisassociateIamInstanceProfileError>;
fn disassociate_route_table(
&self,
input: DisassociateRouteTableRequest,
) -> RusotoFuture<(), DisassociateRouteTableError>;
fn disassociate_subnet_cidr_block(
&self,
input: DisassociateSubnetCidrBlockRequest,
) -> RusotoFuture<DisassociateSubnetCidrBlockResult, DisassociateSubnetCidrBlockError>;
fn disassociate_transit_gateway_route_table(
&self,
input: DisassociateTransitGatewayRouteTableRequest,
) -> RusotoFuture<
DisassociateTransitGatewayRouteTableResult,
DisassociateTransitGatewayRouteTableError,
>;
fn disassociate_vpc_cidr_block(
&self,
input: DisassociateVpcCidrBlockRequest,
) -> RusotoFuture<DisassociateVpcCidrBlockResult, DisassociateVpcCidrBlockError>;
fn enable_ebs_encryption_by_default(
&self,
input: EnableEbsEncryptionByDefaultRequest,
) -> RusotoFuture<EnableEbsEncryptionByDefaultResult, EnableEbsEncryptionByDefaultError>;
fn enable_transit_gateway_route_table_propagation(
&self,
input: EnableTransitGatewayRouteTablePropagationRequest,
) -> RusotoFuture<
EnableTransitGatewayRouteTablePropagationResult,
EnableTransitGatewayRouteTablePropagationError,
>;
fn enable_vgw_route_propagation(
&self,
input: EnableVgwRoutePropagationRequest,
) -> RusotoFuture<(), EnableVgwRoutePropagationError>;
fn enable_volume_io(
&self,
input: EnableVolumeIORequest,
) -> RusotoFuture<(), EnableVolumeIOError>;
fn enable_vpc_classic_link(
&self,
input: EnableVpcClassicLinkRequest,
) -> RusotoFuture<EnableVpcClassicLinkResult, EnableVpcClassicLinkError>;
fn enable_vpc_classic_link_dns_support(
&self,
input: EnableVpcClassicLinkDnsSupportRequest,
) -> RusotoFuture<EnableVpcClassicLinkDnsSupportResult, EnableVpcClassicLinkDnsSupportError>;
fn export_client_vpn_client_certificate_revocation_list(
&self,
input: ExportClientVpnClientCertificateRevocationListRequest,
) -> RusotoFuture<
ExportClientVpnClientCertificateRevocationListResult,
ExportClientVpnClientCertificateRevocationListError,
>;
fn export_client_vpn_client_configuration(
&self,
input: ExportClientVpnClientConfigurationRequest,
) -> RusotoFuture<
ExportClientVpnClientConfigurationResult,
ExportClientVpnClientConfigurationError,
>;
fn export_transit_gateway_routes(
&self,
input: ExportTransitGatewayRoutesRequest,
) -> RusotoFuture<ExportTransitGatewayRoutesResult, ExportTransitGatewayRoutesError>;
fn get_console_output(
&self,
input: GetConsoleOutputRequest,
) -> RusotoFuture<GetConsoleOutputResult, GetConsoleOutputError>;
fn get_console_screenshot(
&self,
input: GetConsoleScreenshotRequest,
) -> RusotoFuture<GetConsoleScreenshotResult, GetConsoleScreenshotError>;
fn get_ebs_default_kms_key_id(
&self,
input: GetEbsDefaultKmsKeyIdRequest,
) -> RusotoFuture<GetEbsDefaultKmsKeyIdResult, GetEbsDefaultKmsKeyIdError>;
fn get_ebs_encryption_by_default(
&self,
input: GetEbsEncryptionByDefaultRequest,
) -> RusotoFuture<GetEbsEncryptionByDefaultResult, GetEbsEncryptionByDefaultError>;
fn get_host_reservation_purchase_preview(
&self,
input: GetHostReservationPurchasePreviewRequest,
) -> RusotoFuture<GetHostReservationPurchasePreviewResult, GetHostReservationPurchasePreviewError>;
fn get_launch_template_data(
&self,
input: GetLaunchTemplateDataRequest,
) -> RusotoFuture<GetLaunchTemplateDataResult, GetLaunchTemplateDataError>;
fn get_password_data(
&self,
input: GetPasswordDataRequest,
) -> RusotoFuture<GetPasswordDataResult, GetPasswordDataError>;
fn get_reserved_instances_exchange_quote(
&self,
input: GetReservedInstancesExchangeQuoteRequest,
) -> RusotoFuture<GetReservedInstancesExchangeQuoteResult, GetReservedInstancesExchangeQuoteError>;
fn get_transit_gateway_attachment_propagations(
&self,
input: GetTransitGatewayAttachmentPropagationsRequest,
) -> RusotoFuture<
GetTransitGatewayAttachmentPropagationsResult,
GetTransitGatewayAttachmentPropagationsError,
>;
fn get_transit_gateway_route_table_associations(
&self,
input: GetTransitGatewayRouteTableAssociationsRequest,
) -> RusotoFuture<
GetTransitGatewayRouteTableAssociationsResult,
GetTransitGatewayRouteTableAssociationsError,
>;
fn get_transit_gateway_route_table_propagations(
&self,
input: GetTransitGatewayRouteTablePropagationsRequest,
) -> RusotoFuture<
GetTransitGatewayRouteTablePropagationsResult,
GetTransitGatewayRouteTablePropagationsError,
>;
fn import_client_vpn_client_certificate_revocation_list(
&self,
input: ImportClientVpnClientCertificateRevocationListRequest,
) -> RusotoFuture<
ImportClientVpnClientCertificateRevocationListResult,
ImportClientVpnClientCertificateRevocationListError,
>;
fn import_image(
&self,
input: ImportImageRequest,
) -> RusotoFuture<ImportImageResult, ImportImageError>;
fn import_instance(
&self,
input: ImportInstanceRequest,
) -> RusotoFuture<ImportInstanceResult, ImportInstanceError>;
fn import_key_pair(
&self,
input: ImportKeyPairRequest,
) -> RusotoFuture<ImportKeyPairResult, ImportKeyPairError>;
fn import_snapshot(
&self,
input: ImportSnapshotRequest,
) -> RusotoFuture<ImportSnapshotResult, ImportSnapshotError>;
fn import_volume(
&self,
input: ImportVolumeRequest,
) -> RusotoFuture<ImportVolumeResult, ImportVolumeError>;
fn modify_capacity_reservation(
&self,
input: ModifyCapacityReservationRequest,
) -> RusotoFuture<ModifyCapacityReservationResult, ModifyCapacityReservationError>;
fn modify_client_vpn_endpoint(
&self,
input: ModifyClientVpnEndpointRequest,
) -> RusotoFuture<ModifyClientVpnEndpointResult, ModifyClientVpnEndpointError>;
fn modify_ebs_default_kms_key_id(
&self,
input: ModifyEbsDefaultKmsKeyIdRequest,
) -> RusotoFuture<ModifyEbsDefaultKmsKeyIdResult, ModifyEbsDefaultKmsKeyIdError>;
fn modify_fleet(
&self,
input: ModifyFleetRequest,
) -> RusotoFuture<ModifyFleetResult, ModifyFleetError>;
fn modify_fpga_image_attribute(
&self,
input: ModifyFpgaImageAttributeRequest,
) -> RusotoFuture<ModifyFpgaImageAttributeResult, ModifyFpgaImageAttributeError>;
fn modify_hosts(
&self,
input: ModifyHostsRequest,
) -> RusotoFuture<ModifyHostsResult, ModifyHostsError>;
fn modify_id_format(
&self,
input: ModifyIdFormatRequest,
) -> RusotoFuture<(), ModifyIdFormatError>;
fn modify_identity_id_format(
&self,
input: ModifyIdentityIdFormatRequest,
) -> RusotoFuture<(), ModifyIdentityIdFormatError>;
fn modify_image_attribute(
&self,
input: ModifyImageAttributeRequest,
) -> RusotoFuture<(), ModifyImageAttributeError>;
fn modify_instance_attribute(
&self,
input: ModifyInstanceAttributeRequest,
) -> RusotoFuture<(), ModifyInstanceAttributeError>;
fn modify_instance_capacity_reservation_attributes(
&self,
input: ModifyInstanceCapacityReservationAttributesRequest,
) -> RusotoFuture<
ModifyInstanceCapacityReservationAttributesResult,
ModifyInstanceCapacityReservationAttributesError,
>;
fn modify_instance_credit_specification(
&self,
input: ModifyInstanceCreditSpecificationRequest,
) -> RusotoFuture<ModifyInstanceCreditSpecificationResult, ModifyInstanceCreditSpecificationError>;
fn modify_instance_event_start_time(
&self,
input: ModifyInstanceEventStartTimeRequest,
) -> RusotoFuture<ModifyInstanceEventStartTimeResult, ModifyInstanceEventStartTimeError>;
fn modify_instance_placement(
&self,
input: ModifyInstancePlacementRequest,
) -> RusotoFuture<ModifyInstancePlacementResult, ModifyInstancePlacementError>;
fn modify_launch_template(
&self,
input: ModifyLaunchTemplateRequest,
) -> RusotoFuture<ModifyLaunchTemplateResult, ModifyLaunchTemplateError>;
fn modify_network_interface_attribute(
&self,
input: ModifyNetworkInterfaceAttributeRequest,
) -> RusotoFuture<(), ModifyNetworkInterfaceAttributeError>;
fn modify_reserved_instances(
&self,
input: ModifyReservedInstancesRequest,
) -> RusotoFuture<ModifyReservedInstancesResult, ModifyReservedInstancesError>;
fn modify_snapshot_attribute(
&self,
input: ModifySnapshotAttributeRequest,
) -> RusotoFuture<(), ModifySnapshotAttributeError>;
fn modify_spot_fleet_request(
&self,
input: ModifySpotFleetRequestRequest,
) -> RusotoFuture<ModifySpotFleetRequestResponse, ModifySpotFleetRequestError>;
fn modify_subnet_attribute(
&self,
input: ModifySubnetAttributeRequest,
) -> RusotoFuture<(), ModifySubnetAttributeError>;
fn modify_transit_gateway_vpc_attachment(
&self,
input: ModifyTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<ModifyTransitGatewayVpcAttachmentResult, ModifyTransitGatewayVpcAttachmentError>;
fn modify_volume(
&self,
input: ModifyVolumeRequest,
) -> RusotoFuture<ModifyVolumeResult, ModifyVolumeError>;
fn modify_volume_attribute(
&self,
input: ModifyVolumeAttributeRequest,
) -> RusotoFuture<(), ModifyVolumeAttributeError>;
fn modify_vpc_attribute(
&self,
input: ModifyVpcAttributeRequest,
) -> RusotoFuture<(), ModifyVpcAttributeError>;
fn modify_vpc_endpoint(
&self,
input: ModifyVpcEndpointRequest,
) -> RusotoFuture<ModifyVpcEndpointResult, ModifyVpcEndpointError>;
fn modify_vpc_endpoint_connection_notification(
&self,
input: ModifyVpcEndpointConnectionNotificationRequest,
) -> RusotoFuture<
ModifyVpcEndpointConnectionNotificationResult,
ModifyVpcEndpointConnectionNotificationError,
>;
fn modify_vpc_endpoint_service_configuration(
&self,
input: ModifyVpcEndpointServiceConfigurationRequest,
) -> RusotoFuture<
ModifyVpcEndpointServiceConfigurationResult,
ModifyVpcEndpointServiceConfigurationError,
>;
fn modify_vpc_endpoint_service_permissions(
&self,
input: ModifyVpcEndpointServicePermissionsRequest,
) -> RusotoFuture<
ModifyVpcEndpointServicePermissionsResult,
ModifyVpcEndpointServicePermissionsError,
>;
fn modify_vpc_peering_connection_options(
&self,
input: ModifyVpcPeeringConnectionOptionsRequest,
) -> RusotoFuture<ModifyVpcPeeringConnectionOptionsResult, ModifyVpcPeeringConnectionOptionsError>;
fn modify_vpc_tenancy(
&self,
input: ModifyVpcTenancyRequest,
) -> RusotoFuture<ModifyVpcTenancyResult, ModifyVpcTenancyError>;
fn modify_vpn_connection(
&self,
input: ModifyVpnConnectionRequest,
) -> RusotoFuture<ModifyVpnConnectionResult, ModifyVpnConnectionError>;
fn monitor_instances(
&self,
input: MonitorInstancesRequest,
) -> RusotoFuture<MonitorInstancesResult, MonitorInstancesError>;
fn move_address_to_vpc(
&self,
input: MoveAddressToVpcRequest,
) -> RusotoFuture<MoveAddressToVpcResult, MoveAddressToVpcError>;
fn provision_byoip_cidr(
&self,
input: ProvisionByoipCidrRequest,
) -> RusotoFuture<ProvisionByoipCidrResult, ProvisionByoipCidrError>;
fn purchase_host_reservation(
&self,
input: PurchaseHostReservationRequest,
) -> RusotoFuture<PurchaseHostReservationResult, PurchaseHostReservationError>;
fn purchase_reserved_instances_offering(
&self,
input: PurchaseReservedInstancesOfferingRequest,
) -> RusotoFuture<PurchaseReservedInstancesOfferingResult, PurchaseReservedInstancesOfferingError>;
fn purchase_scheduled_instances(
&self,
input: PurchaseScheduledInstancesRequest,
) -> RusotoFuture<PurchaseScheduledInstancesResult, PurchaseScheduledInstancesError>;
fn reboot_instances(
&self,
input: RebootInstancesRequest,
) -> RusotoFuture<(), RebootInstancesError>;
fn register_image(
&self,
input: RegisterImageRequest,
) -> RusotoFuture<RegisterImageResult, RegisterImageError>;
fn reject_transit_gateway_vpc_attachment(
&self,
input: RejectTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<RejectTransitGatewayVpcAttachmentResult, RejectTransitGatewayVpcAttachmentError>;
fn reject_vpc_endpoint_connections(
&self,
input: RejectVpcEndpointConnectionsRequest,
) -> RusotoFuture<RejectVpcEndpointConnectionsResult, RejectVpcEndpointConnectionsError>;
fn reject_vpc_peering_connection(
&self,
input: RejectVpcPeeringConnectionRequest,
) -> RusotoFuture<RejectVpcPeeringConnectionResult, RejectVpcPeeringConnectionError>;
fn release_address(
&self,
input: ReleaseAddressRequest,
) -> RusotoFuture<(), ReleaseAddressError>;
fn release_hosts(
&self,
input: ReleaseHostsRequest,
) -> RusotoFuture<ReleaseHostsResult, ReleaseHostsError>;
fn replace_iam_instance_profile_association(
&self,
input: ReplaceIamInstanceProfileAssociationRequest,
) -> RusotoFuture<
ReplaceIamInstanceProfileAssociationResult,
ReplaceIamInstanceProfileAssociationError,
>;
fn replace_network_acl_association(
&self,
input: ReplaceNetworkAclAssociationRequest,
) -> RusotoFuture<ReplaceNetworkAclAssociationResult, ReplaceNetworkAclAssociationError>;
fn replace_network_acl_entry(
&self,
input: ReplaceNetworkAclEntryRequest,
) -> RusotoFuture<(), ReplaceNetworkAclEntryError>;
fn replace_route(&self, input: ReplaceRouteRequest) -> RusotoFuture<(), ReplaceRouteError>;
fn replace_route_table_association(
&self,
input: ReplaceRouteTableAssociationRequest,
) -> RusotoFuture<ReplaceRouteTableAssociationResult, ReplaceRouteTableAssociationError>;
fn replace_transit_gateway_route(
&self,
input: ReplaceTransitGatewayRouteRequest,
) -> RusotoFuture<ReplaceTransitGatewayRouteResult, ReplaceTransitGatewayRouteError>;
fn report_instance_status(
&self,
input: ReportInstanceStatusRequest,
) -> RusotoFuture<(), ReportInstanceStatusError>;
fn request_spot_fleet(
&self,
input: RequestSpotFleetRequest,
) -> RusotoFuture<RequestSpotFleetResponse, RequestSpotFleetError>;
fn request_spot_instances(
&self,
input: RequestSpotInstancesRequest,
) -> RusotoFuture<RequestSpotInstancesResult, RequestSpotInstancesError>;
fn reset_ebs_default_kms_key_id(
&self,
input: ResetEbsDefaultKmsKeyIdRequest,
) -> RusotoFuture<ResetEbsDefaultKmsKeyIdResult, ResetEbsDefaultKmsKeyIdError>;
fn reset_fpga_image_attribute(
&self,
input: ResetFpgaImageAttributeRequest,
) -> RusotoFuture<ResetFpgaImageAttributeResult, ResetFpgaImageAttributeError>;
fn reset_image_attribute(
&self,
input: ResetImageAttributeRequest,
) -> RusotoFuture<(), ResetImageAttributeError>;
fn reset_instance_attribute(
&self,
input: ResetInstanceAttributeRequest,
) -> RusotoFuture<(), ResetInstanceAttributeError>;
fn reset_network_interface_attribute(
&self,
input: ResetNetworkInterfaceAttributeRequest,
) -> RusotoFuture<(), ResetNetworkInterfaceAttributeError>;
fn reset_snapshot_attribute(
&self,
input: ResetSnapshotAttributeRequest,
) -> RusotoFuture<(), ResetSnapshotAttributeError>;
fn restore_address_to_classic(
&self,
input: RestoreAddressToClassicRequest,
) -> RusotoFuture<RestoreAddressToClassicResult, RestoreAddressToClassicError>;
fn revoke_client_vpn_ingress(
&self,
input: RevokeClientVpnIngressRequest,
) -> RusotoFuture<RevokeClientVpnIngressResult, RevokeClientVpnIngressError>;
fn revoke_security_group_egress(
&self,
input: RevokeSecurityGroupEgressRequest,
) -> RusotoFuture<(), RevokeSecurityGroupEgressError>;
fn revoke_security_group_ingress(
&self,
input: RevokeSecurityGroupIngressRequest,
) -> RusotoFuture<(), RevokeSecurityGroupIngressError>;
fn run_instances(
&self,
input: RunInstancesRequest,
) -> RusotoFuture<Reservation, RunInstancesError>;
fn run_scheduled_instances(
&self,
input: RunScheduledInstancesRequest,
) -> RusotoFuture<RunScheduledInstancesResult, RunScheduledInstancesError>;
fn search_transit_gateway_routes(
&self,
input: SearchTransitGatewayRoutesRequest,
) -> RusotoFuture<SearchTransitGatewayRoutesResult, SearchTransitGatewayRoutesError>;
fn start_instances(
&self,
input: StartInstancesRequest,
) -> RusotoFuture<StartInstancesResult, StartInstancesError>;
fn stop_instances(
&self,
input: StopInstancesRequest,
) -> RusotoFuture<StopInstancesResult, StopInstancesError>;
fn terminate_client_vpn_connections(
&self,
input: TerminateClientVpnConnectionsRequest,
) -> RusotoFuture<TerminateClientVpnConnectionsResult, TerminateClientVpnConnectionsError>;
fn terminate_instances(
&self,
input: TerminateInstancesRequest,
) -> RusotoFuture<TerminateInstancesResult, TerminateInstancesError>;
fn unassign_ipv_6_addresses(
&self,
input: UnassignIpv6AddressesRequest,
) -> RusotoFuture<UnassignIpv6AddressesResult, UnassignIpv6AddressesError>;
fn unassign_private_ip_addresses(
&self,
input: UnassignPrivateIpAddressesRequest,
) -> RusotoFuture<(), UnassignPrivateIpAddressesError>;
fn unmonitor_instances(
&self,
input: UnmonitorInstancesRequest,
) -> RusotoFuture<UnmonitorInstancesResult, UnmonitorInstancesError>;
fn update_security_group_rule_descriptions_egress(
&self,
input: UpdateSecurityGroupRuleDescriptionsEgressRequest,
) -> RusotoFuture<
UpdateSecurityGroupRuleDescriptionsEgressResult,
UpdateSecurityGroupRuleDescriptionsEgressError,
>;
fn update_security_group_rule_descriptions_ingress(
&self,
input: UpdateSecurityGroupRuleDescriptionsIngressRequest,
) -> RusotoFuture<
UpdateSecurityGroupRuleDescriptionsIngressResult,
UpdateSecurityGroupRuleDescriptionsIngressError,
>;
fn withdraw_byoip_cidr(
&self,
input: WithdrawByoipCidrRequest,
) -> RusotoFuture<WithdrawByoipCidrResult, WithdrawByoipCidrError>;
}
#[derive(Clone)]
pub struct Ec2Client {
client: Client,
region: region::Region,
}
impl Ec2Client {
pub fn new(region: region::Region) -> Ec2Client {
Ec2Client {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> Ec2Client
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
Ec2Client {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
}
impl Ec2 for Ec2Client {
fn accept_reserved_instances_exchange_quote(
&self,
input: AcceptReservedInstancesExchangeQuoteRequest,
) -> RusotoFuture<
AcceptReservedInstancesExchangeQuoteResult,
AcceptReservedInstancesExchangeQuoteError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AcceptReservedInstancesExchangeQuote");
params.put("Version", "2016-11-15");
AcceptReservedInstancesExchangeQuoteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AcceptReservedInstancesExchangeQuoteError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AcceptReservedInstancesExchangeQuoteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AcceptReservedInstancesExchangeQuoteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn accept_transit_gateway_vpc_attachment(
&self,
input: AcceptTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<AcceptTransitGatewayVpcAttachmentResult, AcceptTransitGatewayVpcAttachmentError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AcceptTransitGatewayVpcAttachment");
params.put("Version", "2016-11-15");
AcceptTransitGatewayVpcAttachmentRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AcceptTransitGatewayVpcAttachmentError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AcceptTransitGatewayVpcAttachmentResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AcceptTransitGatewayVpcAttachmentResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn accept_vpc_endpoint_connections(
&self,
input: AcceptVpcEndpointConnectionsRequest,
) -> RusotoFuture<AcceptVpcEndpointConnectionsResult, AcceptVpcEndpointConnectionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AcceptVpcEndpointConnections");
params.put("Version", "2016-11-15");
AcceptVpcEndpointConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AcceptVpcEndpointConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AcceptVpcEndpointConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AcceptVpcEndpointConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn accept_vpc_peering_connection(
&self,
input: AcceptVpcPeeringConnectionRequest,
) -> RusotoFuture<AcceptVpcPeeringConnectionResult, AcceptVpcPeeringConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AcceptVpcPeeringConnection");
params.put("Version", "2016-11-15");
AcceptVpcPeeringConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AcceptVpcPeeringConnectionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AcceptVpcPeeringConnectionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AcceptVpcPeeringConnectionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn advertise_byoip_cidr(
&self,
input: AdvertiseByoipCidrRequest,
) -> RusotoFuture<AdvertiseByoipCidrResult, AdvertiseByoipCidrError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AdvertiseByoipCidr");
params.put("Version", "2016-11-15");
AdvertiseByoipCidrRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AdvertiseByoipCidrError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AdvertiseByoipCidrResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AdvertiseByoipCidrResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn allocate_address(
&self,
input: AllocateAddressRequest,
) -> RusotoFuture<AllocateAddressResult, AllocateAddressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AllocateAddress");
params.put("Version", "2016-11-15");
AllocateAddressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AllocateAddressError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AllocateAddressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AllocateAddressResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn allocate_hosts(
&self,
input: AllocateHostsRequest,
) -> RusotoFuture<AllocateHostsResult, AllocateHostsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AllocateHosts");
params.put("Version", "2016-11-15");
AllocateHostsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AllocateHostsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AllocateHostsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
AllocateHostsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn apply_security_groups_to_client_vpn_target_network(
&self,
input: ApplySecurityGroupsToClientVpnTargetNetworkRequest,
) -> RusotoFuture<
ApplySecurityGroupsToClientVpnTargetNetworkResult,
ApplySecurityGroupsToClientVpnTargetNetworkError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ApplySecurityGroupsToClientVpnTargetNetwork");
params.put("Version", "2016-11-15");
ApplySecurityGroupsToClientVpnTargetNetworkRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ApplySecurityGroupsToClientVpnTargetNetworkError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ApplySecurityGroupsToClientVpnTargetNetworkResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ApplySecurityGroupsToClientVpnTargetNetworkResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn assign_ipv_6_addresses(
&self,
input: AssignIpv6AddressesRequest,
) -> RusotoFuture<AssignIpv6AddressesResult, AssignIpv6AddressesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssignIpv6Addresses");
params.put("Version", "2016-11-15");
AssignIpv6AddressesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(AssignIpv6AddressesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssignIpv6AddressesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssignIpv6AddressesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn assign_private_ip_addresses(
&self,
input: AssignPrivateIpAddressesRequest,
) -> RusotoFuture<(), AssignPrivateIpAddressesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssignPrivateIpAddresses");
params.put("Version", "2016-11-15");
AssignPrivateIpAddressesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssignPrivateIpAddressesError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn associate_address(
&self,
input: AssociateAddressRequest,
) -> RusotoFuture<AssociateAddressResult, AssociateAddressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateAddress");
params.put("Version", "2016-11-15");
AssociateAddressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AssociateAddressError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateAddressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateAddressResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn associate_client_vpn_target_network(
&self,
input: AssociateClientVpnTargetNetworkRequest,
) -> RusotoFuture<AssociateClientVpnTargetNetworkResult, AssociateClientVpnTargetNetworkError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateClientVpnTargetNetwork");
params.put("Version", "2016-11-15");
AssociateClientVpnTargetNetworkRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateClientVpnTargetNetworkError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateClientVpnTargetNetworkResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateClientVpnTargetNetworkResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn associate_dhcp_options(
&self,
input: AssociateDhcpOptionsRequest,
) -> RusotoFuture<(), AssociateDhcpOptionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateDhcpOptions");
params.put("Version", "2016-11-15");
AssociateDhcpOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(AssociateDhcpOptionsError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn associate_iam_instance_profile(
&self,
input: AssociateIamInstanceProfileRequest,
) -> RusotoFuture<AssociateIamInstanceProfileResult, AssociateIamInstanceProfileError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateIamInstanceProfile");
params.put("Version", "2016-11-15");
AssociateIamInstanceProfileRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateIamInstanceProfileError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateIamInstanceProfileResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateIamInstanceProfileResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn associate_route_table(
&self,
input: AssociateRouteTableRequest,
) -> RusotoFuture<AssociateRouteTableResult, AssociateRouteTableError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateRouteTable");
params.put("Version", "2016-11-15");
AssociateRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(AssociateRouteTableError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateRouteTableResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateRouteTableResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn associate_subnet_cidr_block(
&self,
input: AssociateSubnetCidrBlockRequest,
) -> RusotoFuture<AssociateSubnetCidrBlockResult, AssociateSubnetCidrBlockError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateSubnetCidrBlock");
params.put("Version", "2016-11-15");
AssociateSubnetCidrBlockRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateSubnetCidrBlockError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateSubnetCidrBlockResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateSubnetCidrBlockResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn associate_transit_gateway_route_table(
&self,
input: AssociateTransitGatewayRouteTableRequest,
) -> RusotoFuture<AssociateTransitGatewayRouteTableResult, AssociateTransitGatewayRouteTableError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateTransitGatewayRouteTable");
params.put("Version", "2016-11-15");
AssociateTransitGatewayRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateTransitGatewayRouteTableError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateTransitGatewayRouteTableResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateTransitGatewayRouteTableResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn associate_vpc_cidr_block(
&self,
input: AssociateVpcCidrBlockRequest,
) -> RusotoFuture<AssociateVpcCidrBlockResult, AssociateVpcCidrBlockError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AssociateVpcCidrBlock");
params.put("Version", "2016-11-15");
AssociateVpcCidrBlockRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateVpcCidrBlockError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AssociateVpcCidrBlockResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AssociateVpcCidrBlockResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn attach_classic_link_vpc(
&self,
input: AttachClassicLinkVpcRequest,
) -> RusotoFuture<AttachClassicLinkVpcResult, AttachClassicLinkVpcError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachClassicLinkVpc");
params.put("Version", "2016-11-15");
AttachClassicLinkVpcRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(AttachClassicLinkVpcError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AttachClassicLinkVpcResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AttachClassicLinkVpcResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn attach_internet_gateway(
&self,
input: AttachInternetGatewayRequest,
) -> RusotoFuture<(), AttachInternetGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachInternetGateway");
params.put("Version", "2016-11-15");
AttachInternetGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AttachInternetGatewayError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn attach_network_interface(
&self,
input: AttachNetworkInterfaceRequest,
) -> RusotoFuture<AttachNetworkInterfaceResult, AttachNetworkInterfaceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachNetworkInterface");
params.put("Version", "2016-11-15");
AttachNetworkInterfaceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AttachNetworkInterfaceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AttachNetworkInterfaceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AttachNetworkInterfaceResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn attach_volume(
&self,
input: AttachVolumeRequest,
) -> RusotoFuture<VolumeAttachment, AttachVolumeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachVolume");
params.put("Version", "2016-11-15");
AttachVolumeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AttachVolumeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = VolumeAttachment::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
VolumeAttachmentDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn attach_vpn_gateway(
&self,
input: AttachVpnGatewayRequest,
) -> RusotoFuture<AttachVpnGatewayResult, AttachVpnGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachVpnGateway");
params.put("Version", "2016-11-15");
AttachVpnGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AttachVpnGatewayError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AttachVpnGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AttachVpnGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn authorize_client_vpn_ingress(
&self,
input: AuthorizeClientVpnIngressRequest,
) -> RusotoFuture<AuthorizeClientVpnIngressResult, AuthorizeClientVpnIngressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AuthorizeClientVpnIngress");
params.put("Version", "2016-11-15");
AuthorizeClientVpnIngressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AuthorizeClientVpnIngressError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AuthorizeClientVpnIngressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = AuthorizeClientVpnIngressResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn authorize_security_group_egress(
&self,
input: AuthorizeSecurityGroupEgressRequest,
) -> RusotoFuture<(), AuthorizeSecurityGroupEgressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AuthorizeSecurityGroupEgress");
params.put("Version", "2016-11-15");
AuthorizeSecurityGroupEgressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AuthorizeSecurityGroupEgressError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn authorize_security_group_ingress(
&self,
input: AuthorizeSecurityGroupIngressRequest,
) -> RusotoFuture<(), AuthorizeSecurityGroupIngressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AuthorizeSecurityGroupIngress");
params.put("Version", "2016-11-15");
AuthorizeSecurityGroupIngressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AuthorizeSecurityGroupIngressError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn bundle_instance(
&self,
input: BundleInstanceRequest,
) -> RusotoFuture<BundleInstanceResult, BundleInstanceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "BundleInstance");
params.put("Version", "2016-11-15");
BundleInstanceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(BundleInstanceError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = BundleInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = BundleInstanceResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn cancel_bundle_task(
&self,
input: CancelBundleTaskRequest,
) -> RusotoFuture<CancelBundleTaskResult, CancelBundleTaskError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelBundleTask");
params.put("Version", "2016-11-15");
CancelBundleTaskRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CancelBundleTaskError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CancelBundleTaskResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CancelBundleTaskResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn cancel_capacity_reservation(
&self,
input: CancelCapacityReservationRequest,
) -> RusotoFuture<CancelCapacityReservationResult, CancelCapacityReservationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelCapacityReservation");
params.put("Version", "2016-11-15");
CancelCapacityReservationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CancelCapacityReservationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CancelCapacityReservationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CancelCapacityReservationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn cancel_conversion_task(
&self,
input: CancelConversionRequest,
) -> RusotoFuture<(), CancelConversionTaskError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelConversionTask");
params.put("Version", "2016-11-15");
CancelConversionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CancelConversionTaskError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn cancel_export_task(
&self,
input: CancelExportTaskRequest,
) -> RusotoFuture<(), CancelExportTaskError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelExportTask");
params.put("Version", "2016-11-15");
CancelExportTaskRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CancelExportTaskError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn cancel_import_task(
&self,
input: CancelImportTaskRequest,
) -> RusotoFuture<CancelImportTaskResult, CancelImportTaskError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelImportTask");
params.put("Version", "2016-11-15");
CancelImportTaskRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CancelImportTaskError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CancelImportTaskResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CancelImportTaskResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn cancel_reserved_instances_listing(
&self,
input: CancelReservedInstancesListingRequest,
) -> RusotoFuture<CancelReservedInstancesListingResult, CancelReservedInstancesListingError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelReservedInstancesListing");
params.put("Version", "2016-11-15");
CancelReservedInstancesListingRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CancelReservedInstancesListingError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CancelReservedInstancesListingResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CancelReservedInstancesListingResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn cancel_spot_fleet_requests(
&self,
input: CancelSpotFleetRequestsRequest,
) -> RusotoFuture<CancelSpotFleetRequestsResponse, EC2CancelSpotFleetRequestsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelSpotFleetRequests");
params.put("Version", "2016-11-15");
CancelSpotFleetRequestsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(EC2CancelSpotFleetRequestsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CancelSpotFleetRequestsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CancelSpotFleetRequestsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn cancel_spot_instance_requests(
&self,
input: CancelSpotInstanceRequestsRequest,
) -> RusotoFuture<CancelSpotInstanceRequestsResult, CancelSpotInstanceRequestsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CancelSpotInstanceRequests");
params.put("Version", "2016-11-15");
CancelSpotInstanceRequestsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CancelSpotInstanceRequestsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CancelSpotInstanceRequestsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CancelSpotInstanceRequestsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn confirm_product_instance(
&self,
input: ConfirmProductInstanceRequest,
) -> RusotoFuture<ConfirmProductInstanceResult, ConfirmProductInstanceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ConfirmProductInstance");
params.put("Version", "2016-11-15");
ConfirmProductInstanceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ConfirmProductInstanceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ConfirmProductInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ConfirmProductInstanceResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn copy_fpga_image(
&self,
input: CopyFpgaImageRequest,
) -> RusotoFuture<CopyFpgaImageResult, CopyFpgaImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopyFpgaImage");
params.put("Version", "2016-11-15");
CopyFpgaImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CopyFpgaImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopyFpgaImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CopyFpgaImageResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn copy_image(&self, input: CopyImageRequest) -> RusotoFuture<CopyImageResult, CopyImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopyImage");
params.put("Version", "2016-11-15");
CopyImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CopyImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopyImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CopyImageResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn copy_snapshot(
&self,
input: CopySnapshotRequest,
) -> RusotoFuture<CopySnapshotResult, CopySnapshotError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopySnapshot");
params.put("Version", "2016-11-15");
CopySnapshotRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CopySnapshotError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopySnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CopySnapshotResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_capacity_reservation(
&self,
input: CreateCapacityReservationRequest,
) -> RusotoFuture<CreateCapacityReservationResult, CreateCapacityReservationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateCapacityReservation");
params.put("Version", "2016-11-15");
CreateCapacityReservationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateCapacityReservationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateCapacityReservationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateCapacityReservationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_client_vpn_endpoint(
&self,
input: CreateClientVpnEndpointRequest,
) -> RusotoFuture<CreateClientVpnEndpointResult, CreateClientVpnEndpointError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateClientVpnEndpoint");
params.put("Version", "2016-11-15");
CreateClientVpnEndpointRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateClientVpnEndpointError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClientVpnEndpointResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateClientVpnEndpointResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_client_vpn_route(
&self,
input: CreateClientVpnRouteRequest,
) -> RusotoFuture<CreateClientVpnRouteResult, CreateClientVpnRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateClientVpnRoute");
params.put("Version", "2016-11-15");
CreateClientVpnRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateClientVpnRouteError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClientVpnRouteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateClientVpnRouteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_customer_gateway(
&self,
input: CreateCustomerGatewayRequest,
) -> RusotoFuture<CreateCustomerGatewayResult, CreateCustomerGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateCustomerGateway");
params.put("Version", "2016-11-15");
CreateCustomerGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateCustomerGatewayError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateCustomerGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateCustomerGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_default_subnet(
&self,
input: CreateDefaultSubnetRequest,
) -> RusotoFuture<CreateDefaultSubnetResult, CreateDefaultSubnetError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDefaultSubnet");
params.put("Version", "2016-11-15");
CreateDefaultSubnetRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateDefaultSubnetError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDefaultSubnetResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateDefaultSubnetResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_default_vpc(
&self,
input: CreateDefaultVpcRequest,
) -> RusotoFuture<CreateDefaultVpcResult, CreateDefaultVpcError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDefaultVpc");
params.put("Version", "2016-11-15");
CreateDefaultVpcRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDefaultVpcError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDefaultVpcResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateDefaultVpcResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_dhcp_options(
&self,
input: CreateDhcpOptionsRequest,
) -> RusotoFuture<CreateDhcpOptionsResult, CreateDhcpOptionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDhcpOptions");
params.put("Version", "2016-11-15");
CreateDhcpOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDhcpOptionsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDhcpOptionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateDhcpOptionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_egress_only_internet_gateway(
&self,
input: CreateEgressOnlyInternetGatewayRequest,
) -> RusotoFuture<CreateEgressOnlyInternetGatewayResult, CreateEgressOnlyInternetGatewayError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateEgressOnlyInternetGateway");
params.put("Version", "2016-11-15");
CreateEgressOnlyInternetGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateEgressOnlyInternetGatewayError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateEgressOnlyInternetGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateEgressOnlyInternetGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_fleet(
&self,
input: CreateFleetRequest,
) -> RusotoFuture<CreateFleetResult, CreateFleetError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateFleet");
params.put("Version", "2016-11-15");
CreateFleetRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateFleetError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateFleetResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CreateFleetResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_flow_logs(
&self,
input: CreateFlowLogsRequest,
) -> RusotoFuture<CreateFlowLogsResult, CreateFlowLogsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateFlowLogs");
params.put("Version", "2016-11-15");
CreateFlowLogsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateFlowLogsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateFlowLogsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateFlowLogsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_fpga_image(
&self,
input: CreateFpgaImageRequest,
) -> RusotoFuture<CreateFpgaImageResult, CreateFpgaImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateFpgaImage");
params.put("Version", "2016-11-15");
CreateFpgaImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateFpgaImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateFpgaImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateFpgaImageResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_image(
&self,
input: CreateImageRequest,
) -> RusotoFuture<CreateImageResult, CreateImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateImage");
params.put("Version", "2016-11-15");
CreateImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CreateImageResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_instance_export_task(
&self,
input: CreateInstanceExportTaskRequest,
) -> RusotoFuture<CreateInstanceExportTaskResult, CreateInstanceExportTaskError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateInstanceExportTask");
params.put("Version", "2016-11-15");
CreateInstanceExportTaskRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateInstanceExportTaskError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateInstanceExportTaskResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateInstanceExportTaskResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_internet_gateway(
&self,
input: CreateInternetGatewayRequest,
) -> RusotoFuture<CreateInternetGatewayResult, CreateInternetGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateInternetGateway");
params.put("Version", "2016-11-15");
CreateInternetGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateInternetGatewayError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateInternetGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateInternetGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_key_pair(
&self,
input: CreateKeyPairRequest,
) -> RusotoFuture<KeyPair, CreateKeyPairError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateKeyPair");
params.put("Version", "2016-11-15");
CreateKeyPairRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateKeyPairError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = KeyPair::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = KeyPairDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_launch_template(
&self,
input: CreateLaunchTemplateRequest,
) -> RusotoFuture<CreateLaunchTemplateResult, CreateLaunchTemplateError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateLaunchTemplate");
params.put("Version", "2016-11-15");
CreateLaunchTemplateRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateLaunchTemplateError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateLaunchTemplateResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateLaunchTemplateResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_launch_template_version(
&self,
input: CreateLaunchTemplateVersionRequest,
) -> RusotoFuture<CreateLaunchTemplateVersionResult, CreateLaunchTemplateVersionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateLaunchTemplateVersion");
params.put("Version", "2016-11-15");
CreateLaunchTemplateVersionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateLaunchTemplateVersionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateLaunchTemplateVersionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateLaunchTemplateVersionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_nat_gateway(
&self,
input: CreateNatGatewayRequest,
) -> RusotoFuture<CreateNatGatewayResult, CreateNatGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateNatGateway");
params.put("Version", "2016-11-15");
CreateNatGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateNatGatewayError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateNatGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateNatGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_network_acl(
&self,
input: CreateNetworkAclRequest,
) -> RusotoFuture<CreateNetworkAclResult, CreateNetworkAclError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateNetworkAcl");
params.put("Version", "2016-11-15");
CreateNetworkAclRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateNetworkAclError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateNetworkAclResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateNetworkAclResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_network_acl_entry(
&self,
input: CreateNetworkAclEntryRequest,
) -> RusotoFuture<(), CreateNetworkAclEntryError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateNetworkAclEntry");
params.put("Version", "2016-11-15");
CreateNetworkAclEntryRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateNetworkAclEntryError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn create_network_interface(
&self,
input: CreateNetworkInterfaceRequest,
) -> RusotoFuture<CreateNetworkInterfaceResult, CreateNetworkInterfaceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateNetworkInterface");
params.put("Version", "2016-11-15");
CreateNetworkInterfaceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateNetworkInterfaceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateNetworkInterfaceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateNetworkInterfaceResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_network_interface_permission(
&self,
input: CreateNetworkInterfacePermissionRequest,
) -> RusotoFuture<CreateNetworkInterfacePermissionResult, CreateNetworkInterfacePermissionError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateNetworkInterfacePermission");
params.put("Version", "2016-11-15");
CreateNetworkInterfacePermissionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateNetworkInterfacePermissionError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateNetworkInterfacePermissionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateNetworkInterfacePermissionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_placement_group(
&self,
input: CreatePlacementGroupRequest,
) -> RusotoFuture<(), CreatePlacementGroupError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreatePlacementGroup");
params.put("Version", "2016-11-15");
CreatePlacementGroupRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreatePlacementGroupError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn create_reserved_instances_listing(
&self,
input: CreateReservedInstancesListingRequest,
) -> RusotoFuture<CreateReservedInstancesListingResult, CreateReservedInstancesListingError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateReservedInstancesListing");
params.put("Version", "2016-11-15");
CreateReservedInstancesListingRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateReservedInstancesListingError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateReservedInstancesListingResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateReservedInstancesListingResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_route(
&self,
input: CreateRouteRequest,
) -> RusotoFuture<CreateRouteResult, CreateRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateRoute");
params.put("Version", "2016-11-15");
CreateRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateRouteError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateRouteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CreateRouteResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_route_table(
&self,
input: CreateRouteTableRequest,
) -> RusotoFuture<CreateRouteTableResult, CreateRouteTableError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateRouteTable");
params.put("Version", "2016-11-15");
CreateRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateRouteTableError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateRouteTableResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateRouteTableResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_security_group(
&self,
input: CreateSecurityGroupRequest,
) -> RusotoFuture<CreateSecurityGroupResult, CreateSecurityGroupError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateSecurityGroup");
params.put("Version", "2016-11-15");
CreateSecurityGroupRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateSecurityGroupError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateSecurityGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateSecurityGroupResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_snapshot(
&self,
input: CreateSnapshotRequest,
) -> RusotoFuture<Snapshot, CreateSnapshotError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateSnapshot");
params.put("Version", "2016-11-15");
CreateSnapshotRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateSnapshotError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = Snapshot::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = SnapshotDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_snapshots(
&self,
input: CreateSnapshotsRequest,
) -> RusotoFuture<CreateSnapshotsResult, CreateSnapshotsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateSnapshots");
params.put("Version", "2016-11-15");
CreateSnapshotsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateSnapshotsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateSnapshotsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateSnapshotsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_spot_datafeed_subscription(
&self,
input: CreateSpotDatafeedSubscriptionRequest,
) -> RusotoFuture<CreateSpotDatafeedSubscriptionResult, CreateSpotDatafeedSubscriptionError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateSpotDatafeedSubscription");
params.put("Version", "2016-11-15");
CreateSpotDatafeedSubscriptionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateSpotDatafeedSubscriptionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateSpotDatafeedSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateSpotDatafeedSubscriptionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_subnet(
&self,
input: CreateSubnetRequest,
) -> RusotoFuture<CreateSubnetResult, CreateSubnetError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateSubnet");
params.put("Version", "2016-11-15");
CreateSubnetRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateSubnetError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateSubnetResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CreateSubnetResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_tags(&self, input: CreateTagsRequest) -> RusotoFuture<(), CreateTagsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateTags");
params.put("Version", "2016-11-15");
CreateTagsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateTagsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn create_transit_gateway(
&self,
input: CreateTransitGatewayRequest,
) -> RusotoFuture<CreateTransitGatewayResult, CreateTransitGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateTransitGateway");
params.put("Version", "2016-11-15");
CreateTransitGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateTransitGatewayError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateTransitGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateTransitGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_transit_gateway_route(
&self,
input: CreateTransitGatewayRouteRequest,
) -> RusotoFuture<CreateTransitGatewayRouteResult, CreateTransitGatewayRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateTransitGatewayRoute");
params.put("Version", "2016-11-15");
CreateTransitGatewayRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateTransitGatewayRouteError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateTransitGatewayRouteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateTransitGatewayRouteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_transit_gateway_route_table(
&self,
input: CreateTransitGatewayRouteTableRequest,
) -> RusotoFuture<CreateTransitGatewayRouteTableResult, CreateTransitGatewayRouteTableError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateTransitGatewayRouteTable");
params.put("Version", "2016-11-15");
CreateTransitGatewayRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateTransitGatewayRouteTableError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateTransitGatewayRouteTableResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateTransitGatewayRouteTableResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_transit_gateway_vpc_attachment(
&self,
input: CreateTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<CreateTransitGatewayVpcAttachmentResult, CreateTransitGatewayVpcAttachmentError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateTransitGatewayVpcAttachment");
params.put("Version", "2016-11-15");
CreateTransitGatewayVpcAttachmentRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateTransitGatewayVpcAttachmentError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateTransitGatewayVpcAttachmentResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateTransitGatewayVpcAttachmentResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_volume(&self, input: CreateVolumeRequest) -> RusotoFuture<Volume, CreateVolumeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVolume");
params.put("Version", "2016-11-15");
CreateVolumeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateVolumeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = Volume::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = VolumeDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_vpc(&self, input: CreateVpcRequest) -> RusotoFuture<CreateVpcResult, CreateVpcError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpc");
params.put("Version", "2016-11-15");
CreateVpcRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateVpcError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpcResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CreateVpcResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_vpc_endpoint(
&self,
input: CreateVpcEndpointRequest,
) -> RusotoFuture<CreateVpcEndpointResult, CreateVpcEndpointError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpcEndpoint");
params.put("Version", "2016-11-15");
CreateVpcEndpointRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateVpcEndpointError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpcEndpointResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateVpcEndpointResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_vpc_endpoint_connection_notification(
&self,
input: CreateVpcEndpointConnectionNotificationRequest,
) -> RusotoFuture<
CreateVpcEndpointConnectionNotificationResult,
CreateVpcEndpointConnectionNotificationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpcEndpointConnectionNotification");
params.put("Version", "2016-11-15");
CreateVpcEndpointConnectionNotificationRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateVpcEndpointConnectionNotificationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpcEndpointConnectionNotificationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
CreateVpcEndpointConnectionNotificationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_vpc_endpoint_service_configuration(
&self,
input: CreateVpcEndpointServiceConfigurationRequest,
) -> RusotoFuture<
CreateVpcEndpointServiceConfigurationResult,
CreateVpcEndpointServiceConfigurationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpcEndpointServiceConfiguration");
params.put("Version", "2016-11-15");
CreateVpcEndpointServiceConfigurationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateVpcEndpointServiceConfigurationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpcEndpointServiceConfigurationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateVpcEndpointServiceConfigurationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_vpc_peering_connection(
&self,
input: CreateVpcPeeringConnectionRequest,
) -> RusotoFuture<CreateVpcPeeringConnectionResult, CreateVpcPeeringConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpcPeeringConnection");
params.put("Version", "2016-11-15");
CreateVpcPeeringConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateVpcPeeringConnectionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpcPeeringConnectionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateVpcPeeringConnectionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_vpn_connection(
&self,
input: CreateVpnConnectionRequest,
) -> RusotoFuture<CreateVpnConnectionResult, CreateVpnConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpnConnection");
params.put("Version", "2016-11-15");
CreateVpnConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateVpnConnectionError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpnConnectionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateVpnConnectionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn create_vpn_connection_route(
&self,
input: CreateVpnConnectionRouteRequest,
) -> RusotoFuture<(), CreateVpnConnectionRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpnConnectionRoute");
params.put("Version", "2016-11-15");
CreateVpnConnectionRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateVpnConnectionRouteError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn create_vpn_gateway(
&self,
input: CreateVpnGatewayRequest,
) -> RusotoFuture<CreateVpnGatewayResult, CreateVpnGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateVpnGateway");
params.put("Version", "2016-11-15");
CreateVpnGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateVpnGatewayError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateVpnGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateVpnGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_client_vpn_endpoint(
&self,
input: DeleteClientVpnEndpointRequest,
) -> RusotoFuture<DeleteClientVpnEndpointResult, DeleteClientVpnEndpointError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteClientVpnEndpoint");
params.put("Version", "2016-11-15");
DeleteClientVpnEndpointRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteClientVpnEndpointError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteClientVpnEndpointResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteClientVpnEndpointResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_client_vpn_route(
&self,
input: DeleteClientVpnRouteRequest,
) -> RusotoFuture<DeleteClientVpnRouteResult, DeleteClientVpnRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteClientVpnRoute");
params.put("Version", "2016-11-15");
DeleteClientVpnRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteClientVpnRouteError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteClientVpnRouteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteClientVpnRouteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_customer_gateway(
&self,
input: DeleteCustomerGatewayRequest,
) -> RusotoFuture<(), DeleteCustomerGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteCustomerGateway");
params.put("Version", "2016-11-15");
DeleteCustomerGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteCustomerGatewayError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_dhcp_options(
&self,
input: DeleteDhcpOptionsRequest,
) -> RusotoFuture<(), DeleteDhcpOptionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDhcpOptions");
params.put("Version", "2016-11-15");
DeleteDhcpOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteDhcpOptionsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_egress_only_internet_gateway(
&self,
input: DeleteEgressOnlyInternetGatewayRequest,
) -> RusotoFuture<DeleteEgressOnlyInternetGatewayResult, DeleteEgressOnlyInternetGatewayError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteEgressOnlyInternetGateway");
params.put("Version", "2016-11-15");
DeleteEgressOnlyInternetGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteEgressOnlyInternetGatewayError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteEgressOnlyInternetGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteEgressOnlyInternetGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_fleets(
&self,
input: DeleteFleetsRequest,
) -> RusotoFuture<DeleteFleetsResult, DeleteFleetsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteFleets");
params.put("Version", "2016-11-15");
DeleteFleetsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteFleetsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteFleetsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DeleteFleetsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn delete_flow_logs(
&self,
input: DeleteFlowLogsRequest,
) -> RusotoFuture<DeleteFlowLogsResult, DeleteFlowLogsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteFlowLogs");
params.put("Version", "2016-11-15");
DeleteFlowLogsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteFlowLogsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteFlowLogsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteFlowLogsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_fpga_image(
&self,
input: DeleteFpgaImageRequest,
) -> RusotoFuture<DeleteFpgaImageResult, DeleteFpgaImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteFpgaImage");
params.put("Version", "2016-11-15");
DeleteFpgaImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteFpgaImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteFpgaImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteFpgaImageResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_internet_gateway(
&self,
input: DeleteInternetGatewayRequest,
) -> RusotoFuture<(), DeleteInternetGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteInternetGateway");
params.put("Version", "2016-11-15");
DeleteInternetGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteInternetGatewayError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_key_pair(&self, input: DeleteKeyPairRequest) -> RusotoFuture<(), DeleteKeyPairError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteKeyPair");
params.put("Version", "2016-11-15");
DeleteKeyPairRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteKeyPairError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_launch_template(
&self,
input: DeleteLaunchTemplateRequest,
) -> RusotoFuture<DeleteLaunchTemplateResult, DeleteLaunchTemplateError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteLaunchTemplate");
params.put("Version", "2016-11-15");
DeleteLaunchTemplateRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteLaunchTemplateError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteLaunchTemplateResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteLaunchTemplateResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_launch_template_versions(
&self,
input: DeleteLaunchTemplateVersionsRequest,
) -> RusotoFuture<DeleteLaunchTemplateVersionsResult, DeleteLaunchTemplateVersionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteLaunchTemplateVersions");
params.put("Version", "2016-11-15");
DeleteLaunchTemplateVersionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteLaunchTemplateVersionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteLaunchTemplateVersionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteLaunchTemplateVersionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_nat_gateway(
&self,
input: DeleteNatGatewayRequest,
) -> RusotoFuture<DeleteNatGatewayResult, DeleteNatGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteNatGateway");
params.put("Version", "2016-11-15");
DeleteNatGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteNatGatewayError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteNatGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteNatGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_network_acl(
&self,
input: DeleteNetworkAclRequest,
) -> RusotoFuture<(), DeleteNetworkAclError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteNetworkAcl");
params.put("Version", "2016-11-15");
DeleteNetworkAclRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteNetworkAclError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_network_acl_entry(
&self,
input: DeleteNetworkAclEntryRequest,
) -> RusotoFuture<(), DeleteNetworkAclEntryError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteNetworkAclEntry");
params.put("Version", "2016-11-15");
DeleteNetworkAclEntryRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteNetworkAclEntryError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_network_interface(
&self,
input: DeleteNetworkInterfaceRequest,
) -> RusotoFuture<(), DeleteNetworkInterfaceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteNetworkInterface");
params.put("Version", "2016-11-15");
DeleteNetworkInterfaceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteNetworkInterfaceError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_network_interface_permission(
&self,
input: DeleteNetworkInterfacePermissionRequest,
) -> RusotoFuture<DeleteNetworkInterfacePermissionResult, DeleteNetworkInterfacePermissionError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteNetworkInterfacePermission");
params.put("Version", "2016-11-15");
DeleteNetworkInterfacePermissionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteNetworkInterfacePermissionError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteNetworkInterfacePermissionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteNetworkInterfacePermissionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_placement_group(
&self,
input: DeletePlacementGroupRequest,
) -> RusotoFuture<(), DeletePlacementGroupError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeletePlacementGroup");
params.put("Version", "2016-11-15");
DeletePlacementGroupRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeletePlacementGroupError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_route(&self, input: DeleteRouteRequest) -> RusotoFuture<(), DeleteRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteRoute");
params.put("Version", "2016-11-15");
DeleteRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteRouteError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_route_table(
&self,
input: DeleteRouteTableRequest,
) -> RusotoFuture<(), DeleteRouteTableError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteRouteTable");
params.put("Version", "2016-11-15");
DeleteRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteRouteTableError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_security_group(
&self,
input: DeleteSecurityGroupRequest,
) -> RusotoFuture<(), DeleteSecurityGroupError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteSecurityGroup");
params.put("Version", "2016-11-15");
DeleteSecurityGroupRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteSecurityGroupError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_snapshot(
&self,
input: DeleteSnapshotRequest,
) -> RusotoFuture<(), DeleteSnapshotError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteSnapshot");
params.put("Version", "2016-11-15");
DeleteSnapshotRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteSnapshotError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_spot_datafeed_subscription(
&self,
input: DeleteSpotDatafeedSubscriptionRequest,
) -> RusotoFuture<(), DeleteSpotDatafeedSubscriptionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteSpotDatafeedSubscription");
params.put("Version", "2016-11-15");
DeleteSpotDatafeedSubscriptionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteSpotDatafeedSubscriptionError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_subnet(&self, input: DeleteSubnetRequest) -> RusotoFuture<(), DeleteSubnetError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteSubnet");
params.put("Version", "2016-11-15");
DeleteSubnetRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteSubnetError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_tags(&self, input: DeleteTagsRequest) -> RusotoFuture<(), DeleteTagsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTags");
params.put("Version", "2016-11-15");
DeleteTagsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteTagsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_transit_gateway(
&self,
input: DeleteTransitGatewayRequest,
) -> RusotoFuture<DeleteTransitGatewayResult, DeleteTransitGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTransitGateway");
params.put("Version", "2016-11-15");
DeleteTransitGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteTransitGatewayError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteTransitGatewayResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteTransitGatewayResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_transit_gateway_route(
&self,
input: DeleteTransitGatewayRouteRequest,
) -> RusotoFuture<DeleteTransitGatewayRouteResult, DeleteTransitGatewayRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTransitGatewayRoute");
params.put("Version", "2016-11-15");
DeleteTransitGatewayRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteTransitGatewayRouteError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteTransitGatewayRouteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteTransitGatewayRouteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_transit_gateway_route_table(
&self,
input: DeleteTransitGatewayRouteTableRequest,
) -> RusotoFuture<DeleteTransitGatewayRouteTableResult, DeleteTransitGatewayRouteTableError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTransitGatewayRouteTable");
params.put("Version", "2016-11-15");
DeleteTransitGatewayRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteTransitGatewayRouteTableError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteTransitGatewayRouteTableResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteTransitGatewayRouteTableResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_transit_gateway_vpc_attachment(
&self,
input: DeleteTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<DeleteTransitGatewayVpcAttachmentResult, DeleteTransitGatewayVpcAttachmentError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTransitGatewayVpcAttachment");
params.put("Version", "2016-11-15");
DeleteTransitGatewayVpcAttachmentRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteTransitGatewayVpcAttachmentError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteTransitGatewayVpcAttachmentResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteTransitGatewayVpcAttachmentResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_volume(&self, input: DeleteVolumeRequest) -> RusotoFuture<(), DeleteVolumeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVolume");
params.put("Version", "2016-11-15");
DeleteVolumeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteVolumeError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_vpc(&self, input: DeleteVpcRequest) -> RusotoFuture<(), DeleteVpcError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpc");
params.put("Version", "2016-11-15");
DeleteVpcRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteVpcError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_vpc_endpoint_connection_notifications(
&self,
input: DeleteVpcEndpointConnectionNotificationsRequest,
) -> RusotoFuture<
DeleteVpcEndpointConnectionNotificationsResult,
DeleteVpcEndpointConnectionNotificationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpcEndpointConnectionNotifications");
params.put("Version", "2016-11-15");
DeleteVpcEndpointConnectionNotificationsRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteVpcEndpointConnectionNotificationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteVpcEndpointConnectionNotificationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DeleteVpcEndpointConnectionNotificationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_vpc_endpoint_service_configurations(
&self,
input: DeleteVpcEndpointServiceConfigurationsRequest,
) -> RusotoFuture<
DeleteVpcEndpointServiceConfigurationsResult,
DeleteVpcEndpointServiceConfigurationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpcEndpointServiceConfigurations");
params.put("Version", "2016-11-15");
DeleteVpcEndpointServiceConfigurationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteVpcEndpointServiceConfigurationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteVpcEndpointServiceConfigurationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteVpcEndpointServiceConfigurationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_vpc_endpoints(
&self,
input: DeleteVpcEndpointsRequest,
) -> RusotoFuture<DeleteVpcEndpointsResult, DeleteVpcEndpointsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpcEndpoints");
params.put("Version", "2016-11-15");
DeleteVpcEndpointsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteVpcEndpointsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteVpcEndpointsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteVpcEndpointsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_vpc_peering_connection(
&self,
input: DeleteVpcPeeringConnectionRequest,
) -> RusotoFuture<DeleteVpcPeeringConnectionResult, DeleteVpcPeeringConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpcPeeringConnection");
params.put("Version", "2016-11-15");
DeleteVpcPeeringConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteVpcPeeringConnectionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteVpcPeeringConnectionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeleteVpcPeeringConnectionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn delete_vpn_connection(
&self,
input: DeleteVpnConnectionRequest,
) -> RusotoFuture<(), DeleteVpnConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpnConnection");
params.put("Version", "2016-11-15");
DeleteVpnConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteVpnConnectionError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_vpn_connection_route(
&self,
input: DeleteVpnConnectionRouteRequest,
) -> RusotoFuture<(), DeleteVpnConnectionRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpnConnectionRoute");
params.put("Version", "2016-11-15");
DeleteVpnConnectionRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteVpnConnectionRouteError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_vpn_gateway(
&self,
input: DeleteVpnGatewayRequest,
) -> RusotoFuture<(), DeleteVpnGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteVpnGateway");
params.put("Version", "2016-11-15");
DeleteVpnGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteVpnGatewayError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn deprovision_byoip_cidr(
&self,
input: DeprovisionByoipCidrRequest,
) -> RusotoFuture<DeprovisionByoipCidrResult, DeprovisionByoipCidrError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeprovisionByoipCidr");
params.put("Version", "2016-11-15");
DeprovisionByoipCidrRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeprovisionByoipCidrError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeprovisionByoipCidrResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DeprovisionByoipCidrResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn deregister_image(
&self,
input: DeregisterImageRequest,
) -> RusotoFuture<(), DeregisterImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeregisterImage");
params.put("Version", "2016-11-15");
DeregisterImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeregisterImageError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn describe_account_attributes(
&self,
input: DescribeAccountAttributesRequest,
) -> RusotoFuture<DescribeAccountAttributesResult, DescribeAccountAttributesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAccountAttributes");
params.put("Version", "2016-11-15");
DescribeAccountAttributesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAccountAttributesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAccountAttributesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeAccountAttributesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_addresses(
&self,
input: DescribeAddressesRequest,
) -> RusotoFuture<DescribeAddressesResult, DescribeAddressesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAddresses");
params.put("Version", "2016-11-15");
DescribeAddressesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeAddressesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAddressesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeAddressesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_aggregate_id_format(
&self,
input: DescribeAggregateIdFormatRequest,
) -> RusotoFuture<DescribeAggregateIdFormatResult, DescribeAggregateIdFormatError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAggregateIdFormat");
params.put("Version", "2016-11-15");
DescribeAggregateIdFormatRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAggregateIdFormatError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAggregateIdFormatResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeAggregateIdFormatResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_availability_zones(
&self,
input: DescribeAvailabilityZonesRequest,
) -> RusotoFuture<DescribeAvailabilityZonesResult, DescribeAvailabilityZonesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAvailabilityZones");
params.put("Version", "2016-11-15");
DescribeAvailabilityZonesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAvailabilityZonesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAvailabilityZonesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeAvailabilityZonesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_bundle_tasks(
&self,
input: DescribeBundleTasksRequest,
) -> RusotoFuture<DescribeBundleTasksResult, DescribeBundleTasksError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeBundleTasks");
params.put("Version", "2016-11-15");
DescribeBundleTasksRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeBundleTasksError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeBundleTasksResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeBundleTasksResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_byoip_cidrs(
&self,
input: DescribeByoipCidrsRequest,
) -> RusotoFuture<DescribeByoipCidrsResult, DescribeByoipCidrsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeByoipCidrs");
params.put("Version", "2016-11-15");
DescribeByoipCidrsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeByoipCidrsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeByoipCidrsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeByoipCidrsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_capacity_reservations(
&self,
input: DescribeCapacityReservationsRequest,
) -> RusotoFuture<DescribeCapacityReservationsResult, DescribeCapacityReservationsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeCapacityReservations");
params.put("Version", "2016-11-15");
DescribeCapacityReservationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeCapacityReservationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeCapacityReservationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeCapacityReservationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_classic_link_instances(
&self,
input: DescribeClassicLinkInstancesRequest,
) -> RusotoFuture<DescribeClassicLinkInstancesResult, DescribeClassicLinkInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClassicLinkInstances");
params.put("Version", "2016-11-15");
DescribeClassicLinkInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClassicLinkInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeClassicLinkInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeClassicLinkInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_client_vpn_authorization_rules(
&self,
input: DescribeClientVpnAuthorizationRulesRequest,
) -> RusotoFuture<
DescribeClientVpnAuthorizationRulesResult,
DescribeClientVpnAuthorizationRulesError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClientVpnAuthorizationRules");
params.put("Version", "2016-11-15");
DescribeClientVpnAuthorizationRulesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClientVpnAuthorizationRulesError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeClientVpnAuthorizationRulesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeClientVpnAuthorizationRulesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_client_vpn_connections(
&self,
input: DescribeClientVpnConnectionsRequest,
) -> RusotoFuture<DescribeClientVpnConnectionsResult, DescribeClientVpnConnectionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClientVpnConnections");
params.put("Version", "2016-11-15");
DescribeClientVpnConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClientVpnConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeClientVpnConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeClientVpnConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_client_vpn_endpoints(
&self,
input: DescribeClientVpnEndpointsRequest,
) -> RusotoFuture<DescribeClientVpnEndpointsResult, DescribeClientVpnEndpointsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClientVpnEndpoints");
params.put("Version", "2016-11-15");
DescribeClientVpnEndpointsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClientVpnEndpointsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeClientVpnEndpointsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeClientVpnEndpointsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_client_vpn_routes(
&self,
input: DescribeClientVpnRoutesRequest,
) -> RusotoFuture<DescribeClientVpnRoutesResult, DescribeClientVpnRoutesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClientVpnRoutes");
params.put("Version", "2016-11-15");
DescribeClientVpnRoutesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClientVpnRoutesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeClientVpnRoutesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeClientVpnRoutesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_client_vpn_target_networks(
&self,
input: DescribeClientVpnTargetNetworksRequest,
) -> RusotoFuture<DescribeClientVpnTargetNetworksResult, DescribeClientVpnTargetNetworksError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClientVpnTargetNetworks");
params.put("Version", "2016-11-15");
DescribeClientVpnTargetNetworksRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClientVpnTargetNetworksError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeClientVpnTargetNetworksResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeClientVpnTargetNetworksResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_conversion_tasks(
&self,
input: DescribeConversionTasksRequest,
) -> RusotoFuture<DescribeConversionTasksResult, DescribeConversionTasksError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeConversionTasks");
params.put("Version", "2016-11-15");
DescribeConversionTasksRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeConversionTasksError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeConversionTasksResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeConversionTasksResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_customer_gateways(
&self,
input: DescribeCustomerGatewaysRequest,
) -> RusotoFuture<DescribeCustomerGatewaysResult, DescribeCustomerGatewaysError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeCustomerGateways");
params.put("Version", "2016-11-15");
DescribeCustomerGatewaysRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeCustomerGatewaysError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeCustomerGatewaysResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeCustomerGatewaysResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_dhcp_options(
&self,
input: DescribeDhcpOptionsRequest,
) -> RusotoFuture<DescribeDhcpOptionsResult, DescribeDhcpOptionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDhcpOptions");
params.put("Version", "2016-11-15");
DescribeDhcpOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeDhcpOptionsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeDhcpOptionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeDhcpOptionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_egress_only_internet_gateways(
&self,
input: DescribeEgressOnlyInternetGatewaysRequest,
) -> RusotoFuture<
DescribeEgressOnlyInternetGatewaysResult,
DescribeEgressOnlyInternetGatewaysError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEgressOnlyInternetGateways");
params.put("Version", "2016-11-15");
DescribeEgressOnlyInternetGatewaysRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeEgressOnlyInternetGatewaysError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeEgressOnlyInternetGatewaysResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeEgressOnlyInternetGatewaysResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_elastic_gpus(
&self,
input: DescribeElasticGpusRequest,
) -> RusotoFuture<DescribeElasticGpusResult, DescribeElasticGpusError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeElasticGpus");
params.put("Version", "2016-11-15");
DescribeElasticGpusRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeElasticGpusError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeElasticGpusResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeElasticGpusResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_export_tasks(
&self,
input: DescribeExportTasksRequest,
) -> RusotoFuture<DescribeExportTasksResult, DescribeExportTasksError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeExportTasks");
params.put("Version", "2016-11-15");
DescribeExportTasksRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeExportTasksError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeExportTasksResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeExportTasksResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_fleet_history(
&self,
input: DescribeFleetHistoryRequest,
) -> RusotoFuture<DescribeFleetHistoryResult, DescribeFleetHistoryError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeFleetHistory");
params.put("Version", "2016-11-15");
DescribeFleetHistoryRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeFleetHistoryError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeFleetHistoryResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeFleetHistoryResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_fleet_instances(
&self,
input: DescribeFleetInstancesRequest,
) -> RusotoFuture<DescribeFleetInstancesResult, DescribeFleetInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeFleetInstances");
params.put("Version", "2016-11-15");
DescribeFleetInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeFleetInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeFleetInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeFleetInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_fleets(
&self,
input: DescribeFleetsRequest,
) -> RusotoFuture<DescribeFleetsResult, DescribeFleetsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeFleets");
params.put("Version", "2016-11-15");
DescribeFleetsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeFleetsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeFleetsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeFleetsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_flow_logs(
&self,
input: DescribeFlowLogsRequest,
) -> RusotoFuture<DescribeFlowLogsResult, DescribeFlowLogsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeFlowLogs");
params.put("Version", "2016-11-15");
DescribeFlowLogsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeFlowLogsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeFlowLogsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeFlowLogsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_fpga_image_attribute(
&self,
input: DescribeFpgaImageAttributeRequest,
) -> RusotoFuture<DescribeFpgaImageAttributeResult, DescribeFpgaImageAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeFpgaImageAttribute");
params.put("Version", "2016-11-15");
DescribeFpgaImageAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeFpgaImageAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeFpgaImageAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeFpgaImageAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_fpga_images(
&self,
input: DescribeFpgaImagesRequest,
) -> RusotoFuture<DescribeFpgaImagesResult, DescribeFpgaImagesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeFpgaImages");
params.put("Version", "2016-11-15");
DescribeFpgaImagesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeFpgaImagesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeFpgaImagesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeFpgaImagesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_host_reservation_offerings(
&self,
input: DescribeHostReservationOfferingsRequest,
) -> RusotoFuture<DescribeHostReservationOfferingsResult, DescribeHostReservationOfferingsError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeHostReservationOfferings");
params.put("Version", "2016-11-15");
DescribeHostReservationOfferingsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeHostReservationOfferingsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeHostReservationOfferingsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeHostReservationOfferingsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_host_reservations(
&self,
input: DescribeHostReservationsRequest,
) -> RusotoFuture<DescribeHostReservationsResult, DescribeHostReservationsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeHostReservations");
params.put("Version", "2016-11-15");
DescribeHostReservationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeHostReservationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeHostReservationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeHostReservationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_hosts(
&self,
input: DescribeHostsRequest,
) -> RusotoFuture<DescribeHostsResult, DescribeHostsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeHosts");
params.put("Version", "2016-11-15");
DescribeHostsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeHostsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeHostsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DescribeHostsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_iam_instance_profile_associations(
&self,
input: DescribeIamInstanceProfileAssociationsRequest,
) -> RusotoFuture<
DescribeIamInstanceProfileAssociationsResult,
DescribeIamInstanceProfileAssociationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeIamInstanceProfileAssociations");
params.put("Version", "2016-11-15");
DescribeIamInstanceProfileAssociationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeIamInstanceProfileAssociationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeIamInstanceProfileAssociationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeIamInstanceProfileAssociationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_id_format(
&self,
input: DescribeIdFormatRequest,
) -> RusotoFuture<DescribeIdFormatResult, DescribeIdFormatError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeIdFormat");
params.put("Version", "2016-11-15");
DescribeIdFormatRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeIdFormatError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeIdFormatResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeIdFormatResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_identity_id_format(
&self,
input: DescribeIdentityIdFormatRequest,
) -> RusotoFuture<DescribeIdentityIdFormatResult, DescribeIdentityIdFormatError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeIdentityIdFormat");
params.put("Version", "2016-11-15");
DescribeIdentityIdFormatRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeIdentityIdFormatError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeIdentityIdFormatResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeIdentityIdFormatResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_image_attribute(
&self,
input: DescribeImageAttributeRequest,
) -> RusotoFuture<ImageAttribute, DescribeImageAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeImageAttribute");
params.put("Version", "2016-11-15");
DescribeImageAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeImageAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImageAttribute::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ImageAttributeDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_images(
&self,
input: DescribeImagesRequest,
) -> RusotoFuture<DescribeImagesResult, DescribeImagesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeImages");
params.put("Version", "2016-11-15");
DescribeImagesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeImagesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeImagesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeImagesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_import_image_tasks(
&self,
input: DescribeImportImageTasksRequest,
) -> RusotoFuture<DescribeImportImageTasksResult, DescribeImportImageTasksError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeImportImageTasks");
params.put("Version", "2016-11-15");
DescribeImportImageTasksRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeImportImageTasksError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeImportImageTasksResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeImportImageTasksResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_import_snapshot_tasks(
&self,
input: DescribeImportSnapshotTasksRequest,
) -> RusotoFuture<DescribeImportSnapshotTasksResult, DescribeImportSnapshotTasksError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeImportSnapshotTasks");
params.put("Version", "2016-11-15");
DescribeImportSnapshotTasksRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeImportSnapshotTasksError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeImportSnapshotTasksResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeImportSnapshotTasksResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_instance_attribute(
&self,
input: DescribeInstanceAttributeRequest,
) -> RusotoFuture<InstanceAttribute, DescribeInstanceAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeInstanceAttribute");
params.put("Version", "2016-11-15");
DescribeInstanceAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeInstanceAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = InstanceAttribute::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
InstanceAttributeDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_instance_credit_specifications(
&self,
input: DescribeInstanceCreditSpecificationsRequest,
) -> RusotoFuture<
DescribeInstanceCreditSpecificationsResult,
DescribeInstanceCreditSpecificationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeInstanceCreditSpecifications");
params.put("Version", "2016-11-15");
DescribeInstanceCreditSpecificationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeInstanceCreditSpecificationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeInstanceCreditSpecificationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeInstanceCreditSpecificationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_instance_status(
&self,
input: DescribeInstanceStatusRequest,
) -> RusotoFuture<DescribeInstanceStatusResult, DescribeInstanceStatusError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeInstanceStatus");
params.put("Version", "2016-11-15");
DescribeInstanceStatusRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeInstanceStatusError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeInstanceStatusResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeInstanceStatusResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_instances(
&self,
input: DescribeInstancesRequest,
) -> RusotoFuture<DescribeInstancesResult, DescribeInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeInstances");
params.put("Version", "2016-11-15");
DescribeInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_internet_gateways(
&self,
input: DescribeInternetGatewaysRequest,
) -> RusotoFuture<DescribeInternetGatewaysResult, DescribeInternetGatewaysError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeInternetGateways");
params.put("Version", "2016-11-15");
DescribeInternetGatewaysRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeInternetGatewaysError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeInternetGatewaysResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeInternetGatewaysResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_key_pairs(
&self,
input: DescribeKeyPairsRequest,
) -> RusotoFuture<DescribeKeyPairsResult, DescribeKeyPairsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeKeyPairs");
params.put("Version", "2016-11-15");
DescribeKeyPairsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeKeyPairsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeKeyPairsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeKeyPairsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_launch_template_versions(
&self,
input: DescribeLaunchTemplateVersionsRequest,
) -> RusotoFuture<DescribeLaunchTemplateVersionsResult, DescribeLaunchTemplateVersionsError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLaunchTemplateVersions");
params.put("Version", "2016-11-15");
DescribeLaunchTemplateVersionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLaunchTemplateVersionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeLaunchTemplateVersionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeLaunchTemplateVersionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_launch_templates(
&self,
input: DescribeLaunchTemplatesRequest,
) -> RusotoFuture<DescribeLaunchTemplatesResult, DescribeLaunchTemplatesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLaunchTemplates");
params.put("Version", "2016-11-15");
DescribeLaunchTemplatesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLaunchTemplatesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeLaunchTemplatesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeLaunchTemplatesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_moving_addresses(
&self,
input: DescribeMovingAddressesRequest,
) -> RusotoFuture<DescribeMovingAddressesResult, DescribeMovingAddressesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeMovingAddresses");
params.put("Version", "2016-11-15");
DescribeMovingAddressesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeMovingAddressesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeMovingAddressesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeMovingAddressesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_nat_gateways(
&self,
input: DescribeNatGatewaysRequest,
) -> RusotoFuture<DescribeNatGatewaysResult, DescribeNatGatewaysError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeNatGateways");
params.put("Version", "2016-11-15");
DescribeNatGatewaysRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeNatGatewaysError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeNatGatewaysResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeNatGatewaysResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_network_acls(
&self,
input: DescribeNetworkAclsRequest,
) -> RusotoFuture<DescribeNetworkAclsResult, DescribeNetworkAclsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeNetworkAcls");
params.put("Version", "2016-11-15");
DescribeNetworkAclsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeNetworkAclsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeNetworkAclsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeNetworkAclsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_network_interface_attribute(
&self,
input: DescribeNetworkInterfaceAttributeRequest,
) -> RusotoFuture<DescribeNetworkInterfaceAttributeResult, DescribeNetworkInterfaceAttributeError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeNetworkInterfaceAttribute");
params.put("Version", "2016-11-15");
DescribeNetworkInterfaceAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeNetworkInterfaceAttributeError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeNetworkInterfaceAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeNetworkInterfaceAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_network_interface_permissions(
&self,
input: DescribeNetworkInterfacePermissionsRequest,
) -> RusotoFuture<
DescribeNetworkInterfacePermissionsResult,
DescribeNetworkInterfacePermissionsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeNetworkInterfacePermissions");
params.put("Version", "2016-11-15");
DescribeNetworkInterfacePermissionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeNetworkInterfacePermissionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeNetworkInterfacePermissionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeNetworkInterfacePermissionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_network_interfaces(
&self,
input: DescribeNetworkInterfacesRequest,
) -> RusotoFuture<DescribeNetworkInterfacesResult, DescribeNetworkInterfacesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeNetworkInterfaces");
params.put("Version", "2016-11-15");
DescribeNetworkInterfacesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeNetworkInterfacesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeNetworkInterfacesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeNetworkInterfacesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_placement_groups(
&self,
input: DescribePlacementGroupsRequest,
) -> RusotoFuture<DescribePlacementGroupsResult, DescribePlacementGroupsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribePlacementGroups");
params.put("Version", "2016-11-15");
DescribePlacementGroupsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribePlacementGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribePlacementGroupsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribePlacementGroupsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_prefix_lists(
&self,
input: DescribePrefixListsRequest,
) -> RusotoFuture<DescribePrefixListsResult, DescribePrefixListsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribePrefixLists");
params.put("Version", "2016-11-15");
DescribePrefixListsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribePrefixListsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribePrefixListsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribePrefixListsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_principal_id_format(
&self,
input: DescribePrincipalIdFormatRequest,
) -> RusotoFuture<DescribePrincipalIdFormatResult, DescribePrincipalIdFormatError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribePrincipalIdFormat");
params.put("Version", "2016-11-15");
DescribePrincipalIdFormatRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribePrincipalIdFormatError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribePrincipalIdFormatResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribePrincipalIdFormatResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_public_ipv_4_pools(
&self,
input: DescribePublicIpv4PoolsRequest,
) -> RusotoFuture<DescribePublicIpv4PoolsResult, DescribePublicIpv4PoolsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribePublicIpv4Pools");
params.put("Version", "2016-11-15");
DescribePublicIpv4PoolsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribePublicIpv4PoolsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribePublicIpv4PoolsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribePublicIpv4PoolsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_regions(
&self,
input: DescribeRegionsRequest,
) -> RusotoFuture<DescribeRegionsResult, DescribeRegionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeRegions");
params.put("Version", "2016-11-15");
DescribeRegionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeRegionsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeRegionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeRegionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_reserved_instances(
&self,
input: DescribeReservedInstancesRequest,
) -> RusotoFuture<DescribeReservedInstancesResult, DescribeReservedInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeReservedInstances");
params.put("Version", "2016-11-15");
DescribeReservedInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReservedInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeReservedInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeReservedInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_reserved_instances_listings(
&self,
input: DescribeReservedInstancesListingsRequest,
) -> RusotoFuture<DescribeReservedInstancesListingsResult, DescribeReservedInstancesListingsError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeReservedInstancesListings");
params.put("Version", "2016-11-15");
DescribeReservedInstancesListingsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReservedInstancesListingsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeReservedInstancesListingsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeReservedInstancesListingsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_reserved_instances_modifications(
&self,
input: DescribeReservedInstancesModificationsRequest,
) -> RusotoFuture<
DescribeReservedInstancesModificationsResult,
DescribeReservedInstancesModificationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeReservedInstancesModifications");
params.put("Version", "2016-11-15");
DescribeReservedInstancesModificationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReservedInstancesModificationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeReservedInstancesModificationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeReservedInstancesModificationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_reserved_instances_offerings(
&self,
input: DescribeReservedInstancesOfferingsRequest,
) -> RusotoFuture<
DescribeReservedInstancesOfferingsResult,
DescribeReservedInstancesOfferingsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeReservedInstancesOfferings");
params.put("Version", "2016-11-15");
DescribeReservedInstancesOfferingsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReservedInstancesOfferingsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeReservedInstancesOfferingsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeReservedInstancesOfferingsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_route_tables(
&self,
input: DescribeRouteTablesRequest,
) -> RusotoFuture<DescribeRouteTablesResult, DescribeRouteTablesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeRouteTables");
params.put("Version", "2016-11-15");
DescribeRouteTablesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeRouteTablesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeRouteTablesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeRouteTablesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_scheduled_instance_availability(
&self,
input: DescribeScheduledInstanceAvailabilityRequest,
) -> RusotoFuture<
DescribeScheduledInstanceAvailabilityResult,
DescribeScheduledInstanceAvailabilityError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeScheduledInstanceAvailability");
params.put("Version", "2016-11-15");
DescribeScheduledInstanceAvailabilityRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeScheduledInstanceAvailabilityError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeScheduledInstanceAvailabilityResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeScheduledInstanceAvailabilityResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_scheduled_instances(
&self,
input: DescribeScheduledInstancesRequest,
) -> RusotoFuture<DescribeScheduledInstancesResult, DescribeScheduledInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeScheduledInstances");
params.put("Version", "2016-11-15");
DescribeScheduledInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeScheduledInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeScheduledInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeScheduledInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_security_group_references(
&self,
input: DescribeSecurityGroupReferencesRequest,
) -> RusotoFuture<DescribeSecurityGroupReferencesResult, DescribeSecurityGroupReferencesError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSecurityGroupReferences");
params.put("Version", "2016-11-15");
DescribeSecurityGroupReferencesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSecurityGroupReferencesError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSecurityGroupReferencesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSecurityGroupReferencesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_security_groups(
&self,
input: DescribeSecurityGroupsRequest,
) -> RusotoFuture<DescribeSecurityGroupsResult, DescribeSecurityGroupsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSecurityGroups");
params.put("Version", "2016-11-15");
DescribeSecurityGroupsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSecurityGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSecurityGroupsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSecurityGroupsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_snapshot_attribute(
&self,
input: DescribeSnapshotAttributeRequest,
) -> RusotoFuture<DescribeSnapshotAttributeResult, DescribeSnapshotAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSnapshotAttribute");
params.put("Version", "2016-11-15");
DescribeSnapshotAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSnapshotAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSnapshotAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSnapshotAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_snapshots(
&self,
input: DescribeSnapshotsRequest,
) -> RusotoFuture<DescribeSnapshotsResult, DescribeSnapshotsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSnapshots");
params.put("Version", "2016-11-15");
DescribeSnapshotsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeSnapshotsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSnapshotsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSnapshotsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_spot_datafeed_subscription(
&self,
input: DescribeSpotDatafeedSubscriptionRequest,
) -> RusotoFuture<DescribeSpotDatafeedSubscriptionResult, DescribeSpotDatafeedSubscriptionError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSpotDatafeedSubscription");
params.put("Version", "2016-11-15");
DescribeSpotDatafeedSubscriptionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSpotDatafeedSubscriptionError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSpotDatafeedSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSpotDatafeedSubscriptionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_spot_fleet_instances(
&self,
input: DescribeSpotFleetInstancesRequest,
) -> RusotoFuture<DescribeSpotFleetInstancesResponse, DescribeSpotFleetInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSpotFleetInstances");
params.put("Version", "2016-11-15");
DescribeSpotFleetInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSpotFleetInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSpotFleetInstancesResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSpotFleetInstancesResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_spot_fleet_request_history(
&self,
input: DescribeSpotFleetRequestHistoryRequest,
) -> RusotoFuture<DescribeSpotFleetRequestHistoryResponse, DescribeSpotFleetRequestHistoryError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSpotFleetRequestHistory");
params.put("Version", "2016-11-15");
DescribeSpotFleetRequestHistoryRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSpotFleetRequestHistoryError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSpotFleetRequestHistoryResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSpotFleetRequestHistoryResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_spot_fleet_requests(
&self,
input: DescribeSpotFleetRequestsRequest,
) -> RusotoFuture<DescribeSpotFleetRequestsResponse, DescribeSpotFleetRequestsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSpotFleetRequests");
params.put("Version", "2016-11-15");
DescribeSpotFleetRequestsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSpotFleetRequestsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSpotFleetRequestsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSpotFleetRequestsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_spot_instance_requests(
&self,
input: DescribeSpotInstanceRequestsRequest,
) -> RusotoFuture<DescribeSpotInstanceRequestsResult, DescribeSpotInstanceRequestsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSpotInstanceRequests");
params.put("Version", "2016-11-15");
DescribeSpotInstanceRequestsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSpotInstanceRequestsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSpotInstanceRequestsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSpotInstanceRequestsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_spot_price_history(
&self,
input: DescribeSpotPriceHistoryRequest,
) -> RusotoFuture<DescribeSpotPriceHistoryResult, DescribeSpotPriceHistoryError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSpotPriceHistory");
params.put("Version", "2016-11-15");
DescribeSpotPriceHistoryRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSpotPriceHistoryError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSpotPriceHistoryResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSpotPriceHistoryResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_stale_security_groups(
&self,
input: DescribeStaleSecurityGroupsRequest,
) -> RusotoFuture<DescribeStaleSecurityGroupsResult, DescribeStaleSecurityGroupsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeStaleSecurityGroups");
params.put("Version", "2016-11-15");
DescribeStaleSecurityGroupsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeStaleSecurityGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeStaleSecurityGroupsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeStaleSecurityGroupsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_subnets(
&self,
input: DescribeSubnetsRequest,
) -> RusotoFuture<DescribeSubnetsResult, DescribeSubnetsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSubnets");
params.put("Version", "2016-11-15");
DescribeSubnetsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeSubnetsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSubnetsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeSubnetsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> RusotoFuture<DescribeTagsResult, DescribeTagsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTags");
params.put("Version", "2016-11-15");
DescribeTagsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeTagsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeTagsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DescribeTagsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_transit_gateway_attachments(
&self,
input: DescribeTransitGatewayAttachmentsRequest,
) -> RusotoFuture<DescribeTransitGatewayAttachmentsResult, DescribeTransitGatewayAttachmentsError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTransitGatewayAttachments");
params.put("Version", "2016-11-15");
DescribeTransitGatewayAttachmentsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTransitGatewayAttachmentsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeTransitGatewayAttachmentsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeTransitGatewayAttachmentsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_transit_gateway_route_tables(
&self,
input: DescribeTransitGatewayRouteTablesRequest,
) -> RusotoFuture<DescribeTransitGatewayRouteTablesResult, DescribeTransitGatewayRouteTablesError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTransitGatewayRouteTables");
params.put("Version", "2016-11-15");
DescribeTransitGatewayRouteTablesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTransitGatewayRouteTablesError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeTransitGatewayRouteTablesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeTransitGatewayRouteTablesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_transit_gateway_vpc_attachments(
&self,
input: DescribeTransitGatewayVpcAttachmentsRequest,
) -> RusotoFuture<
DescribeTransitGatewayVpcAttachmentsResult,
DescribeTransitGatewayVpcAttachmentsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTransitGatewayVpcAttachments");
params.put("Version", "2016-11-15");
DescribeTransitGatewayVpcAttachmentsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTransitGatewayVpcAttachmentsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeTransitGatewayVpcAttachmentsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeTransitGatewayVpcAttachmentsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_transit_gateways(
&self,
input: DescribeTransitGatewaysRequest,
) -> RusotoFuture<DescribeTransitGatewaysResult, DescribeTransitGatewaysError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTransitGateways");
params.put("Version", "2016-11-15");
DescribeTransitGatewaysRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTransitGatewaysError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeTransitGatewaysResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeTransitGatewaysResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_volume_attribute(
&self,
input: DescribeVolumeAttributeRequest,
) -> RusotoFuture<DescribeVolumeAttributeResult, DescribeVolumeAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVolumeAttribute");
params.put("Version", "2016-11-15");
DescribeVolumeAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVolumeAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVolumeAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVolumeAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_volume_status(
&self,
input: DescribeVolumeStatusRequest,
) -> RusotoFuture<DescribeVolumeStatusResult, DescribeVolumeStatusError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVolumeStatus");
params.put("Version", "2016-11-15");
DescribeVolumeStatusRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeVolumeStatusError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVolumeStatusResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVolumeStatusResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_volumes(
&self,
input: DescribeVolumesRequest,
) -> RusotoFuture<DescribeVolumesResult, DescribeVolumesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVolumes");
params.put("Version", "2016-11-15");
DescribeVolumesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeVolumesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVolumesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVolumesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_volumes_modifications(
&self,
input: DescribeVolumesModificationsRequest,
) -> RusotoFuture<DescribeVolumesModificationsResult, DescribeVolumesModificationsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVolumesModifications");
params.put("Version", "2016-11-15");
DescribeVolumesModificationsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVolumesModificationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVolumesModificationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVolumesModificationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_attribute(
&self,
input: DescribeVpcAttributeRequest,
) -> RusotoFuture<DescribeVpcAttributeResult, DescribeVpcAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcAttribute");
params.put("Version", "2016-11-15");
DescribeVpcAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeVpcAttributeError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_classic_link(
&self,
input: DescribeVpcClassicLinkRequest,
) -> RusotoFuture<DescribeVpcClassicLinkResult, DescribeVpcClassicLinkError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcClassicLink");
params.put("Version", "2016-11-15");
DescribeVpcClassicLinkRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcClassicLinkError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcClassicLinkResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcClassicLinkResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_classic_link_dns_support(
&self,
input: DescribeVpcClassicLinkDnsSupportRequest,
) -> RusotoFuture<DescribeVpcClassicLinkDnsSupportResult, DescribeVpcClassicLinkDnsSupportError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcClassicLinkDnsSupport");
params.put("Version", "2016-11-15");
DescribeVpcClassicLinkDnsSupportRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcClassicLinkDnsSupportError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcClassicLinkDnsSupportResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcClassicLinkDnsSupportResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_endpoint_connection_notifications(
&self,
input: DescribeVpcEndpointConnectionNotificationsRequest,
) -> RusotoFuture<
DescribeVpcEndpointConnectionNotificationsResult,
DescribeVpcEndpointConnectionNotificationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcEndpointConnectionNotifications");
params.put("Version", "2016-11-15");
DescribeVpcEndpointConnectionNotificationsRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcEndpointConnectionNotificationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcEndpointConnectionNotificationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DescribeVpcEndpointConnectionNotificationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_endpoint_connections(
&self,
input: DescribeVpcEndpointConnectionsRequest,
) -> RusotoFuture<DescribeVpcEndpointConnectionsResult, DescribeVpcEndpointConnectionsError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcEndpointConnections");
params.put("Version", "2016-11-15");
DescribeVpcEndpointConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcEndpointConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcEndpointConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcEndpointConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_endpoint_service_configurations(
&self,
input: DescribeVpcEndpointServiceConfigurationsRequest,
) -> RusotoFuture<
DescribeVpcEndpointServiceConfigurationsResult,
DescribeVpcEndpointServiceConfigurationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcEndpointServiceConfigurations");
params.put("Version", "2016-11-15");
DescribeVpcEndpointServiceConfigurationsRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcEndpointServiceConfigurationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcEndpointServiceConfigurationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DescribeVpcEndpointServiceConfigurationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_endpoint_service_permissions(
&self,
input: DescribeVpcEndpointServicePermissionsRequest,
) -> RusotoFuture<
DescribeVpcEndpointServicePermissionsResult,
DescribeVpcEndpointServicePermissionsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcEndpointServicePermissions");
params.put("Version", "2016-11-15");
DescribeVpcEndpointServicePermissionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcEndpointServicePermissionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcEndpointServicePermissionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcEndpointServicePermissionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_endpoint_services(
&self,
input: DescribeVpcEndpointServicesRequest,
) -> RusotoFuture<DescribeVpcEndpointServicesResult, DescribeVpcEndpointServicesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcEndpointServices");
params.put("Version", "2016-11-15");
DescribeVpcEndpointServicesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcEndpointServicesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcEndpointServicesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcEndpointServicesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_endpoints(
&self,
input: DescribeVpcEndpointsRequest,
) -> RusotoFuture<DescribeVpcEndpointsResult, DescribeVpcEndpointsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcEndpoints");
params.put("Version", "2016-11-15");
DescribeVpcEndpointsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeVpcEndpointsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcEndpointsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcEndpointsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpc_peering_connections(
&self,
input: DescribeVpcPeeringConnectionsRequest,
) -> RusotoFuture<DescribeVpcPeeringConnectionsResult, DescribeVpcPeeringConnectionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcPeeringConnections");
params.put("Version", "2016-11-15");
DescribeVpcPeeringConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpcPeeringConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcPeeringConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpcPeeringConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpcs(
&self,
input: DescribeVpcsRequest,
) -> RusotoFuture<DescribeVpcsResult, DescribeVpcsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpcs");
params.put("Version", "2016-11-15");
DescribeVpcsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeVpcsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpcsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DescribeVpcsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_vpn_connections(
&self,
input: DescribeVpnConnectionsRequest,
) -> RusotoFuture<DescribeVpnConnectionsResult, DescribeVpnConnectionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpnConnections");
params.put("Version", "2016-11-15");
DescribeVpnConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeVpnConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpnConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpnConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn describe_vpn_gateways(
&self,
input: DescribeVpnGatewaysRequest,
) -> RusotoFuture<DescribeVpnGatewaysResult, DescribeVpnGatewaysError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeVpnGateways");
params.put("Version", "2016-11-15");
DescribeVpnGatewaysRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeVpnGatewaysError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeVpnGatewaysResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DescribeVpnGatewaysResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn detach_classic_link_vpc(
&self,
input: DetachClassicLinkVpcRequest,
) -> RusotoFuture<DetachClassicLinkVpcResult, DetachClassicLinkVpcError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachClassicLinkVpc");
params.put("Version", "2016-11-15");
DetachClassicLinkVpcRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DetachClassicLinkVpcError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DetachClassicLinkVpcResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DetachClassicLinkVpcResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn detach_internet_gateway(
&self,
input: DetachInternetGatewayRequest,
) -> RusotoFuture<(), DetachInternetGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachInternetGateway");
params.put("Version", "2016-11-15");
DetachInternetGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DetachInternetGatewayError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn detach_network_interface(
&self,
input: DetachNetworkInterfaceRequest,
) -> RusotoFuture<(), DetachNetworkInterfaceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachNetworkInterface");
params.put("Version", "2016-11-15");
DetachNetworkInterfaceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DetachNetworkInterfaceError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn detach_volume(
&self,
input: DetachVolumeRequest,
) -> RusotoFuture<VolumeAttachment, DetachVolumeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachVolume");
params.put("Version", "2016-11-15");
DetachVolumeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DetachVolumeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = VolumeAttachment::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
VolumeAttachmentDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn detach_vpn_gateway(
&self,
input: DetachVpnGatewayRequest,
) -> RusotoFuture<(), DetachVpnGatewayError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachVpnGateway");
params.put("Version", "2016-11-15");
DetachVpnGatewayRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DetachVpnGatewayError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn disable_ebs_encryption_by_default(
&self,
input: DisableEbsEncryptionByDefaultRequest,
) -> RusotoFuture<DisableEbsEncryptionByDefaultResult, DisableEbsEncryptionByDefaultError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableEbsEncryptionByDefault");
params.put("Version", "2016-11-15");
DisableEbsEncryptionByDefaultRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisableEbsEncryptionByDefaultError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisableEbsEncryptionByDefaultResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisableEbsEncryptionByDefaultResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disable_transit_gateway_route_table_propagation(
&self,
input: DisableTransitGatewayRouteTablePropagationRequest,
) -> RusotoFuture<
DisableTransitGatewayRouteTablePropagationResult,
DisableTransitGatewayRouteTablePropagationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableTransitGatewayRouteTablePropagation");
params.put("Version", "2016-11-15");
DisableTransitGatewayRouteTablePropagationRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisableTransitGatewayRouteTablePropagationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisableTransitGatewayRouteTablePropagationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
DisableTransitGatewayRouteTablePropagationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disable_vgw_route_propagation(
&self,
input: DisableVgwRoutePropagationRequest,
) -> RusotoFuture<(), DisableVgwRoutePropagationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableVgwRoutePropagation");
params.put("Version", "2016-11-15");
DisableVgwRoutePropagationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisableVgwRoutePropagationError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn disable_vpc_classic_link(
&self,
input: DisableVpcClassicLinkRequest,
) -> RusotoFuture<DisableVpcClassicLinkResult, DisableVpcClassicLinkError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableVpcClassicLink");
params.put("Version", "2016-11-15");
DisableVpcClassicLinkRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisableVpcClassicLinkError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisableVpcClassicLinkResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisableVpcClassicLinkResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disable_vpc_classic_link_dns_support(
&self,
input: DisableVpcClassicLinkDnsSupportRequest,
) -> RusotoFuture<DisableVpcClassicLinkDnsSupportResult, DisableVpcClassicLinkDnsSupportError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableVpcClassicLinkDnsSupport");
params.put("Version", "2016-11-15");
DisableVpcClassicLinkDnsSupportRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisableVpcClassicLinkDnsSupportError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisableVpcClassicLinkDnsSupportResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisableVpcClassicLinkDnsSupportResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disassociate_address(
&self,
input: DisassociateAddressRequest,
) -> RusotoFuture<(), DisassociateAddressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateAddress");
params.put("Version", "2016-11-15");
DisassociateAddressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DisassociateAddressError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn disassociate_client_vpn_target_network(
&self,
input: DisassociateClientVpnTargetNetworkRequest,
) -> RusotoFuture<
DisassociateClientVpnTargetNetworkResult,
DisassociateClientVpnTargetNetworkError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateClientVpnTargetNetwork");
params.put("Version", "2016-11-15");
DisassociateClientVpnTargetNetworkRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateClientVpnTargetNetworkError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisassociateClientVpnTargetNetworkResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisassociateClientVpnTargetNetworkResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disassociate_iam_instance_profile(
&self,
input: DisassociateIamInstanceProfileRequest,
) -> RusotoFuture<DisassociateIamInstanceProfileResult, DisassociateIamInstanceProfileError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateIamInstanceProfile");
params.put("Version", "2016-11-15");
DisassociateIamInstanceProfileRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateIamInstanceProfileError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisassociateIamInstanceProfileResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisassociateIamInstanceProfileResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disassociate_route_table(
&self,
input: DisassociateRouteTableRequest,
) -> RusotoFuture<(), DisassociateRouteTableError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateRouteTable");
params.put("Version", "2016-11-15");
DisassociateRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateRouteTableError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn disassociate_subnet_cidr_block(
&self,
input: DisassociateSubnetCidrBlockRequest,
) -> RusotoFuture<DisassociateSubnetCidrBlockResult, DisassociateSubnetCidrBlockError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateSubnetCidrBlock");
params.put("Version", "2016-11-15");
DisassociateSubnetCidrBlockRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateSubnetCidrBlockError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisassociateSubnetCidrBlockResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisassociateSubnetCidrBlockResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disassociate_transit_gateway_route_table(
&self,
input: DisassociateTransitGatewayRouteTableRequest,
) -> RusotoFuture<
DisassociateTransitGatewayRouteTableResult,
DisassociateTransitGatewayRouteTableError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateTransitGatewayRouteTable");
params.put("Version", "2016-11-15");
DisassociateTransitGatewayRouteTableRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateTransitGatewayRouteTableError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisassociateTransitGatewayRouteTableResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisassociateTransitGatewayRouteTableResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn disassociate_vpc_cidr_block(
&self,
input: DisassociateVpcCidrBlockRequest,
) -> RusotoFuture<DisassociateVpcCidrBlockResult, DisassociateVpcCidrBlockError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisassociateVpcCidrBlock");
params.put("Version", "2016-11-15");
DisassociateVpcCidrBlockRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateVpcCidrBlockError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisassociateVpcCidrBlockResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = DisassociateVpcCidrBlockResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn enable_ebs_encryption_by_default(
&self,
input: EnableEbsEncryptionByDefaultRequest,
) -> RusotoFuture<EnableEbsEncryptionByDefaultResult, EnableEbsEncryptionByDefaultError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableEbsEncryptionByDefault");
params.put("Version", "2016-11-15");
EnableEbsEncryptionByDefaultRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(EnableEbsEncryptionByDefaultError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EnableEbsEncryptionByDefaultResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = EnableEbsEncryptionByDefaultResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn enable_transit_gateway_route_table_propagation(
&self,
input: EnableTransitGatewayRouteTablePropagationRequest,
) -> RusotoFuture<
EnableTransitGatewayRouteTablePropagationResult,
EnableTransitGatewayRouteTablePropagationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableTransitGatewayRouteTablePropagation");
params.put("Version", "2016-11-15");
EnableTransitGatewayRouteTablePropagationRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(EnableTransitGatewayRouteTablePropagationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EnableTransitGatewayRouteTablePropagationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
EnableTransitGatewayRouteTablePropagationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn enable_vgw_route_propagation(
&self,
input: EnableVgwRoutePropagationRequest,
) -> RusotoFuture<(), EnableVgwRoutePropagationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableVgwRoutePropagation");
params.put("Version", "2016-11-15");
EnableVgwRoutePropagationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(EnableVgwRoutePropagationError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn enable_volume_io(
&self,
input: EnableVolumeIORequest,
) -> RusotoFuture<(), EnableVolumeIOError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableVolumeIO");
params.put("Version", "2016-11-15");
EnableVolumeIORequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(EnableVolumeIOError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn enable_vpc_classic_link(
&self,
input: EnableVpcClassicLinkRequest,
) -> RusotoFuture<EnableVpcClassicLinkResult, EnableVpcClassicLinkError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableVpcClassicLink");
params.put("Version", "2016-11-15");
EnableVpcClassicLinkRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(EnableVpcClassicLinkError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EnableVpcClassicLinkResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = EnableVpcClassicLinkResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn enable_vpc_classic_link_dns_support(
&self,
input: EnableVpcClassicLinkDnsSupportRequest,
) -> RusotoFuture<EnableVpcClassicLinkDnsSupportResult, EnableVpcClassicLinkDnsSupportError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableVpcClassicLinkDnsSupport");
params.put("Version", "2016-11-15");
EnableVpcClassicLinkDnsSupportRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(EnableVpcClassicLinkDnsSupportError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EnableVpcClassicLinkDnsSupportResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = EnableVpcClassicLinkDnsSupportResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn export_client_vpn_client_certificate_revocation_list(
&self,
input: ExportClientVpnClientCertificateRevocationListRequest,
) -> RusotoFuture<
ExportClientVpnClientCertificateRevocationListResult,
ExportClientVpnClientCertificateRevocationListError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ExportClientVpnClientCertificateRevocationList");
params.put("Version", "2016-11-15");
ExportClientVpnClientCertificateRevocationListRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ExportClientVpnClientCertificateRevocationListError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ExportClientVpnClientCertificateRevocationListResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true)
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ExportClientVpnClientCertificateRevocationListResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn export_client_vpn_client_configuration(
&self,
input: ExportClientVpnClientConfigurationRequest,
) -> RusotoFuture<
ExportClientVpnClientConfigurationResult,
ExportClientVpnClientConfigurationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ExportClientVpnClientConfiguration");
params.put("Version", "2016-11-15");
ExportClientVpnClientConfigurationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ExportClientVpnClientConfigurationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ExportClientVpnClientConfigurationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ExportClientVpnClientConfigurationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn export_transit_gateway_routes(
&self,
input: ExportTransitGatewayRoutesRequest,
) -> RusotoFuture<ExportTransitGatewayRoutesResult, ExportTransitGatewayRoutesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ExportTransitGatewayRoutes");
params.put("Version", "2016-11-15");
ExportTransitGatewayRoutesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ExportTransitGatewayRoutesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ExportTransitGatewayRoutesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ExportTransitGatewayRoutesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_console_output(
&self,
input: GetConsoleOutputRequest,
) -> RusotoFuture<GetConsoleOutputResult, GetConsoleOutputError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetConsoleOutput");
params.put("Version", "2016-11-15");
GetConsoleOutputRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetConsoleOutputError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetConsoleOutputResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetConsoleOutputResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_console_screenshot(
&self,
input: GetConsoleScreenshotRequest,
) -> RusotoFuture<GetConsoleScreenshotResult, GetConsoleScreenshotError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetConsoleScreenshot");
params.put("Version", "2016-11-15");
GetConsoleScreenshotRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetConsoleScreenshotError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetConsoleScreenshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetConsoleScreenshotResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_ebs_default_kms_key_id(
&self,
input: GetEbsDefaultKmsKeyIdRequest,
) -> RusotoFuture<GetEbsDefaultKmsKeyIdResult, GetEbsDefaultKmsKeyIdError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetEbsDefaultKmsKeyId");
params.put("Version", "2016-11-15");
GetEbsDefaultKmsKeyIdRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetEbsDefaultKmsKeyIdError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetEbsDefaultKmsKeyIdResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetEbsDefaultKmsKeyIdResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_ebs_encryption_by_default(
&self,
input: GetEbsEncryptionByDefaultRequest,
) -> RusotoFuture<GetEbsEncryptionByDefaultResult, GetEbsEncryptionByDefaultError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetEbsEncryptionByDefault");
params.put("Version", "2016-11-15");
GetEbsEncryptionByDefaultRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetEbsEncryptionByDefaultError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetEbsEncryptionByDefaultResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetEbsEncryptionByDefaultResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_host_reservation_purchase_preview(
&self,
input: GetHostReservationPurchasePreviewRequest,
) -> RusotoFuture<GetHostReservationPurchasePreviewResult, GetHostReservationPurchasePreviewError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetHostReservationPurchasePreview");
params.put("Version", "2016-11-15");
GetHostReservationPurchasePreviewRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetHostReservationPurchasePreviewError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetHostReservationPurchasePreviewResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetHostReservationPurchasePreviewResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_launch_template_data(
&self,
input: GetLaunchTemplateDataRequest,
) -> RusotoFuture<GetLaunchTemplateDataResult, GetLaunchTemplateDataError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetLaunchTemplateData");
params.put("Version", "2016-11-15");
GetLaunchTemplateDataRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetLaunchTemplateDataError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetLaunchTemplateDataResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetLaunchTemplateDataResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_password_data(
&self,
input: GetPasswordDataRequest,
) -> RusotoFuture<GetPasswordDataResult, GetPasswordDataError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetPasswordData");
params.put("Version", "2016-11-15");
GetPasswordDataRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetPasswordDataError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetPasswordDataResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetPasswordDataResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_reserved_instances_exchange_quote(
&self,
input: GetReservedInstancesExchangeQuoteRequest,
) -> RusotoFuture<GetReservedInstancesExchangeQuoteResult, GetReservedInstancesExchangeQuoteError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetReservedInstancesExchangeQuote");
params.put("Version", "2016-11-15");
GetReservedInstancesExchangeQuoteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetReservedInstancesExchangeQuoteError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetReservedInstancesExchangeQuoteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetReservedInstancesExchangeQuoteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_transit_gateway_attachment_propagations(
&self,
input: GetTransitGatewayAttachmentPropagationsRequest,
) -> RusotoFuture<
GetTransitGatewayAttachmentPropagationsResult,
GetTransitGatewayAttachmentPropagationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetTransitGatewayAttachmentPropagations");
params.put("Version", "2016-11-15");
GetTransitGatewayAttachmentPropagationsRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetTransitGatewayAttachmentPropagationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetTransitGatewayAttachmentPropagationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
GetTransitGatewayAttachmentPropagationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_transit_gateway_route_table_associations(
&self,
input: GetTransitGatewayRouteTableAssociationsRequest,
) -> RusotoFuture<
GetTransitGatewayRouteTableAssociationsResult,
GetTransitGatewayRouteTableAssociationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetTransitGatewayRouteTableAssociations");
params.put("Version", "2016-11-15");
GetTransitGatewayRouteTableAssociationsRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetTransitGatewayRouteTableAssociationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetTransitGatewayRouteTableAssociationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
GetTransitGatewayRouteTableAssociationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn get_transit_gateway_route_table_propagations(
&self,
input: GetTransitGatewayRouteTablePropagationsRequest,
) -> RusotoFuture<
GetTransitGatewayRouteTablePropagationsResult,
GetTransitGatewayRouteTablePropagationsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetTransitGatewayRouteTablePropagations");
params.put("Version", "2016-11-15");
GetTransitGatewayRouteTablePropagationsRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetTransitGatewayRouteTablePropagationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetTransitGatewayRouteTablePropagationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
GetTransitGatewayRouteTablePropagationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn import_client_vpn_client_certificate_revocation_list(
&self,
input: ImportClientVpnClientCertificateRevocationListRequest,
) -> RusotoFuture<
ImportClientVpnClientCertificateRevocationListResult,
ImportClientVpnClientCertificateRevocationListError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ImportClientVpnClientCertificateRevocationList");
params.put("Version", "2016-11-15");
ImportClientVpnClientCertificateRevocationListRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ImportClientVpnClientCertificateRevocationListError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImportClientVpnClientCertificateRevocationListResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true)
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ImportClientVpnClientCertificateRevocationListResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn import_image(
&self,
input: ImportImageRequest,
) -> RusotoFuture<ImportImageResult, ImportImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ImportImage");
params.put("Version", "2016-11-15");
ImportImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImportImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ImportImageResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn import_instance(
&self,
input: ImportInstanceRequest,
) -> RusotoFuture<ImportInstanceResult, ImportInstanceError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ImportInstance");
params.put("Version", "2016-11-15");
ImportInstanceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportInstanceError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImportInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ImportInstanceResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn import_key_pair(
&self,
input: ImportKeyPairRequest,
) -> RusotoFuture<ImportKeyPairResult, ImportKeyPairError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ImportKeyPair");
params.put("Version", "2016-11-15");
ImportKeyPairRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportKeyPairError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImportKeyPairResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ImportKeyPairResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn import_snapshot(
&self,
input: ImportSnapshotRequest,
) -> RusotoFuture<ImportSnapshotResult, ImportSnapshotError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ImportSnapshot");
params.put("Version", "2016-11-15");
ImportSnapshotRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportSnapshotError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImportSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ImportSnapshotResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn import_volume(
&self,
input: ImportVolumeRequest,
) -> RusotoFuture<ImportVolumeResult, ImportVolumeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ImportVolume");
params.put("Version", "2016-11-15");
ImportVolumeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportVolumeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ImportVolumeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ImportVolumeResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_capacity_reservation(
&self,
input: ModifyCapacityReservationRequest,
) -> RusotoFuture<ModifyCapacityReservationResult, ModifyCapacityReservationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyCapacityReservation");
params.put("Version", "2016-11-15");
ModifyCapacityReservationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyCapacityReservationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyCapacityReservationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyCapacityReservationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_client_vpn_endpoint(
&self,
input: ModifyClientVpnEndpointRequest,
) -> RusotoFuture<ModifyClientVpnEndpointResult, ModifyClientVpnEndpointError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyClientVpnEndpoint");
params.put("Version", "2016-11-15");
ModifyClientVpnEndpointRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyClientVpnEndpointError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyClientVpnEndpointResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyClientVpnEndpointResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_ebs_default_kms_key_id(
&self,
input: ModifyEbsDefaultKmsKeyIdRequest,
) -> RusotoFuture<ModifyEbsDefaultKmsKeyIdResult, ModifyEbsDefaultKmsKeyIdError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyEbsDefaultKmsKeyId");
params.put("Version", "2016-11-15");
ModifyEbsDefaultKmsKeyIdRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyEbsDefaultKmsKeyIdError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyEbsDefaultKmsKeyIdResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyEbsDefaultKmsKeyIdResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_fleet(
&self,
input: ModifyFleetRequest,
) -> RusotoFuture<ModifyFleetResult, ModifyFleetError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyFleet");
params.put("Version", "2016-11-15");
ModifyFleetRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyFleetError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyFleetResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ModifyFleetResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_fpga_image_attribute(
&self,
input: ModifyFpgaImageAttributeRequest,
) -> RusotoFuture<ModifyFpgaImageAttributeResult, ModifyFpgaImageAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyFpgaImageAttribute");
params.put("Version", "2016-11-15");
ModifyFpgaImageAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyFpgaImageAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyFpgaImageAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyFpgaImageAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_hosts(
&self,
input: ModifyHostsRequest,
) -> RusotoFuture<ModifyHostsResult, ModifyHostsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyHosts");
params.put("Version", "2016-11-15");
ModifyHostsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyHostsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyHostsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ModifyHostsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_id_format(
&self,
input: ModifyIdFormatRequest,
) -> RusotoFuture<(), ModifyIdFormatError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyIdFormat");
params.put("Version", "2016-11-15");
ModifyIdFormatRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyIdFormatError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_identity_id_format(
&self,
input: ModifyIdentityIdFormatRequest,
) -> RusotoFuture<(), ModifyIdentityIdFormatError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyIdentityIdFormat");
params.put("Version", "2016-11-15");
ModifyIdentityIdFormatRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyIdentityIdFormatError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_image_attribute(
&self,
input: ModifyImageAttributeRequest,
) -> RusotoFuture<(), ModifyImageAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyImageAttribute");
params.put("Version", "2016-11-15");
ModifyImageAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ModifyImageAttributeError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_instance_attribute(
&self,
input: ModifyInstanceAttributeRequest,
) -> RusotoFuture<(), ModifyInstanceAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyInstanceAttribute");
params.put("Version", "2016-11-15");
ModifyInstanceAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyInstanceAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_instance_capacity_reservation_attributes(
&self,
input: ModifyInstanceCapacityReservationAttributesRequest,
) -> RusotoFuture<
ModifyInstanceCapacityReservationAttributesResult,
ModifyInstanceCapacityReservationAttributesError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyInstanceCapacityReservationAttributes");
params.put("Version", "2016-11-15");
ModifyInstanceCapacityReservationAttributesRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyInstanceCapacityReservationAttributesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyInstanceCapacityReservationAttributesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ModifyInstanceCapacityReservationAttributesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_instance_credit_specification(
&self,
input: ModifyInstanceCreditSpecificationRequest,
) -> RusotoFuture<ModifyInstanceCreditSpecificationResult, ModifyInstanceCreditSpecificationError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyInstanceCreditSpecification");
params.put("Version", "2016-11-15");
ModifyInstanceCreditSpecificationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyInstanceCreditSpecificationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyInstanceCreditSpecificationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyInstanceCreditSpecificationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_instance_event_start_time(
&self,
input: ModifyInstanceEventStartTimeRequest,
) -> RusotoFuture<ModifyInstanceEventStartTimeResult, ModifyInstanceEventStartTimeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyInstanceEventStartTime");
params.put("Version", "2016-11-15");
ModifyInstanceEventStartTimeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyInstanceEventStartTimeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyInstanceEventStartTimeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyInstanceEventStartTimeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_instance_placement(
&self,
input: ModifyInstancePlacementRequest,
) -> RusotoFuture<ModifyInstancePlacementResult, ModifyInstancePlacementError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyInstancePlacement");
params.put("Version", "2016-11-15");
ModifyInstancePlacementRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyInstancePlacementError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyInstancePlacementResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyInstancePlacementResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_launch_template(
&self,
input: ModifyLaunchTemplateRequest,
) -> RusotoFuture<ModifyLaunchTemplateResult, ModifyLaunchTemplateError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyLaunchTemplate");
params.put("Version", "2016-11-15");
ModifyLaunchTemplateRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ModifyLaunchTemplateError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyLaunchTemplateResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyLaunchTemplateResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_network_interface_attribute(
&self,
input: ModifyNetworkInterfaceAttributeRequest,
) -> RusotoFuture<(), ModifyNetworkInterfaceAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyNetworkInterfaceAttribute");
params.put("Version", "2016-11-15");
ModifyNetworkInterfaceAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyNetworkInterfaceAttributeError::from_response(
response,
))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_reserved_instances(
&self,
input: ModifyReservedInstancesRequest,
) -> RusotoFuture<ModifyReservedInstancesResult, ModifyReservedInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyReservedInstances");
params.put("Version", "2016-11-15");
ModifyReservedInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyReservedInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyReservedInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyReservedInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_snapshot_attribute(
&self,
input: ModifySnapshotAttributeRequest,
) -> RusotoFuture<(), ModifySnapshotAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifySnapshotAttribute");
params.put("Version", "2016-11-15");
ModifySnapshotAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifySnapshotAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_spot_fleet_request(
&self,
input: ModifySpotFleetRequestRequest,
) -> RusotoFuture<ModifySpotFleetRequestResponse, ModifySpotFleetRequestError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifySpotFleetRequest");
params.put("Version", "2016-11-15");
ModifySpotFleetRequestRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifySpotFleetRequestError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifySpotFleetRequestResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifySpotFleetRequestResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_subnet_attribute(
&self,
input: ModifySubnetAttributeRequest,
) -> RusotoFuture<(), ModifySubnetAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifySubnetAttribute");
params.put("Version", "2016-11-15");
ModifySubnetAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifySubnetAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_transit_gateway_vpc_attachment(
&self,
input: ModifyTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<ModifyTransitGatewayVpcAttachmentResult, ModifyTransitGatewayVpcAttachmentError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyTransitGatewayVpcAttachment");
params.put("Version", "2016-11-15");
ModifyTransitGatewayVpcAttachmentRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyTransitGatewayVpcAttachmentError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyTransitGatewayVpcAttachmentResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyTransitGatewayVpcAttachmentResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_volume(
&self,
input: ModifyVolumeRequest,
) -> RusotoFuture<ModifyVolumeResult, ModifyVolumeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVolume");
params.put("Version", "2016-11-15");
ModifyVolumeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyVolumeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVolumeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ModifyVolumeResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_volume_attribute(
&self,
input: ModifyVolumeAttributeRequest,
) -> RusotoFuture<(), ModifyVolumeAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVolumeAttribute");
params.put("Version", "2016-11-15");
ModifyVolumeAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyVolumeAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_vpc_attribute(
&self,
input: ModifyVpcAttributeRequest,
) -> RusotoFuture<(), ModifyVpcAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcAttribute");
params.put("Version", "2016-11-15");
ModifyVpcAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyVpcAttributeError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn modify_vpc_endpoint(
&self,
input: ModifyVpcEndpointRequest,
) -> RusotoFuture<ModifyVpcEndpointResult, ModifyVpcEndpointError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcEndpoint");
params.put("Version", "2016-11-15");
ModifyVpcEndpointRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyVpcEndpointError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpcEndpointResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyVpcEndpointResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_vpc_endpoint_connection_notification(
&self,
input: ModifyVpcEndpointConnectionNotificationRequest,
) -> RusotoFuture<
ModifyVpcEndpointConnectionNotificationResult,
ModifyVpcEndpointConnectionNotificationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcEndpointConnectionNotification");
params.put("Version", "2016-11-15");
ModifyVpcEndpointConnectionNotificationRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyVpcEndpointConnectionNotificationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpcEndpointConnectionNotificationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ModifyVpcEndpointConnectionNotificationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_vpc_endpoint_service_configuration(
&self,
input: ModifyVpcEndpointServiceConfigurationRequest,
) -> RusotoFuture<
ModifyVpcEndpointServiceConfigurationResult,
ModifyVpcEndpointServiceConfigurationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcEndpointServiceConfiguration");
params.put("Version", "2016-11-15");
ModifyVpcEndpointServiceConfigurationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyVpcEndpointServiceConfigurationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpcEndpointServiceConfigurationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyVpcEndpointServiceConfigurationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_vpc_endpoint_service_permissions(
&self,
input: ModifyVpcEndpointServicePermissionsRequest,
) -> RusotoFuture<
ModifyVpcEndpointServicePermissionsResult,
ModifyVpcEndpointServicePermissionsError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcEndpointServicePermissions");
params.put("Version", "2016-11-15");
ModifyVpcEndpointServicePermissionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyVpcEndpointServicePermissionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpcEndpointServicePermissionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyVpcEndpointServicePermissionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_vpc_peering_connection_options(
&self,
input: ModifyVpcPeeringConnectionOptionsRequest,
) -> RusotoFuture<ModifyVpcPeeringConnectionOptionsResult, ModifyVpcPeeringConnectionOptionsError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcPeeringConnectionOptions");
params.put("Version", "2016-11-15");
ModifyVpcPeeringConnectionOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyVpcPeeringConnectionOptionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpcPeeringConnectionOptionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyVpcPeeringConnectionOptionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_vpc_tenancy(
&self,
input: ModifyVpcTenancyRequest,
) -> RusotoFuture<ModifyVpcTenancyResult, ModifyVpcTenancyError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpcTenancy");
params.put("Version", "2016-11-15");
ModifyVpcTenancyRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyVpcTenancyError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpcTenancyResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyVpcTenancyResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn modify_vpn_connection(
&self,
input: ModifyVpnConnectionRequest,
) -> RusotoFuture<ModifyVpnConnectionResult, ModifyVpnConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyVpnConnection");
params.put("Version", "2016-11-15");
ModifyVpnConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ModifyVpnConnectionError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyVpnConnectionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ModifyVpnConnectionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn monitor_instances(
&self,
input: MonitorInstancesRequest,
) -> RusotoFuture<MonitorInstancesResult, MonitorInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "MonitorInstances");
params.put("Version", "2016-11-15");
MonitorInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(MonitorInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = MonitorInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = MonitorInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn move_address_to_vpc(
&self,
input: MoveAddressToVpcRequest,
) -> RusotoFuture<MoveAddressToVpcResult, MoveAddressToVpcError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "MoveAddressToVpc");
params.put("Version", "2016-11-15");
MoveAddressToVpcRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(MoveAddressToVpcError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = MoveAddressToVpcResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = MoveAddressToVpcResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn provision_byoip_cidr(
&self,
input: ProvisionByoipCidrRequest,
) -> RusotoFuture<ProvisionByoipCidrResult, ProvisionByoipCidrError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ProvisionByoipCidr");
params.put("Version", "2016-11-15");
ProvisionByoipCidrRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ProvisionByoipCidrError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ProvisionByoipCidrResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ProvisionByoipCidrResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn purchase_host_reservation(
&self,
input: PurchaseHostReservationRequest,
) -> RusotoFuture<PurchaseHostReservationResult, PurchaseHostReservationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PurchaseHostReservation");
params.put("Version", "2016-11-15");
PurchaseHostReservationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(PurchaseHostReservationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PurchaseHostReservationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = PurchaseHostReservationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn purchase_reserved_instances_offering(
&self,
input: PurchaseReservedInstancesOfferingRequest,
) -> RusotoFuture<PurchaseReservedInstancesOfferingResult, PurchaseReservedInstancesOfferingError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PurchaseReservedInstancesOffering");
params.put("Version", "2016-11-15");
PurchaseReservedInstancesOfferingRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(PurchaseReservedInstancesOfferingError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PurchaseReservedInstancesOfferingResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = PurchaseReservedInstancesOfferingResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn purchase_scheduled_instances(
&self,
input: PurchaseScheduledInstancesRequest,
) -> RusotoFuture<PurchaseScheduledInstancesResult, PurchaseScheduledInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PurchaseScheduledInstances");
params.put("Version", "2016-11-15");
PurchaseScheduledInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(PurchaseScheduledInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PurchaseScheduledInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = PurchaseScheduledInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn reboot_instances(
&self,
input: RebootInstancesRequest,
) -> RusotoFuture<(), RebootInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RebootInstances");
params.put("Version", "2016-11-15");
RebootInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RebootInstancesError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn register_image(
&self,
input: RegisterImageRequest,
) -> RusotoFuture<RegisterImageResult, RegisterImageError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RegisterImage");
params.put("Version", "2016-11-15");
RegisterImageRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterImageError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RegisterImageResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
RegisterImageResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn reject_transit_gateway_vpc_attachment(
&self,
input: RejectTransitGatewayVpcAttachmentRequest,
) -> RusotoFuture<RejectTransitGatewayVpcAttachmentResult, RejectTransitGatewayVpcAttachmentError>
{
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RejectTransitGatewayVpcAttachment");
params.put("Version", "2016-11-15");
RejectTransitGatewayVpcAttachmentRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RejectTransitGatewayVpcAttachmentError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RejectTransitGatewayVpcAttachmentResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RejectTransitGatewayVpcAttachmentResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn reject_vpc_endpoint_connections(
&self,
input: RejectVpcEndpointConnectionsRequest,
) -> RusotoFuture<RejectVpcEndpointConnectionsResult, RejectVpcEndpointConnectionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RejectVpcEndpointConnections");
params.put("Version", "2016-11-15");
RejectVpcEndpointConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RejectVpcEndpointConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RejectVpcEndpointConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RejectVpcEndpointConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn reject_vpc_peering_connection(
&self,
input: RejectVpcPeeringConnectionRequest,
) -> RusotoFuture<RejectVpcPeeringConnectionResult, RejectVpcPeeringConnectionError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RejectVpcPeeringConnection");
params.put("Version", "2016-11-15");
RejectVpcPeeringConnectionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RejectVpcPeeringConnectionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RejectVpcPeeringConnectionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RejectVpcPeeringConnectionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn release_address(
&self,
input: ReleaseAddressRequest,
) -> RusotoFuture<(), ReleaseAddressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReleaseAddress");
params.put("Version", "2016-11-15");
ReleaseAddressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ReleaseAddressError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn release_hosts(
&self,
input: ReleaseHostsRequest,
) -> RusotoFuture<ReleaseHostsResult, ReleaseHostsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReleaseHosts");
params.put("Version", "2016-11-15");
ReleaseHostsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ReleaseHostsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReleaseHostsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
ReleaseHostsResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn replace_iam_instance_profile_association(
&self,
input: ReplaceIamInstanceProfileAssociationRequest,
) -> RusotoFuture<
ReplaceIamInstanceProfileAssociationResult,
ReplaceIamInstanceProfileAssociationError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReplaceIamInstanceProfileAssociation");
params.put("Version", "2016-11-15");
ReplaceIamInstanceProfileAssociationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ReplaceIamInstanceProfileAssociationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReplaceIamInstanceProfileAssociationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ReplaceIamInstanceProfileAssociationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn replace_network_acl_association(
&self,
input: ReplaceNetworkAclAssociationRequest,
) -> RusotoFuture<ReplaceNetworkAclAssociationResult, ReplaceNetworkAclAssociationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReplaceNetworkAclAssociation");
params.put("Version", "2016-11-15");
ReplaceNetworkAclAssociationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ReplaceNetworkAclAssociationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReplaceNetworkAclAssociationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ReplaceNetworkAclAssociationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn replace_network_acl_entry(
&self,
input: ReplaceNetworkAclEntryRequest,
) -> RusotoFuture<(), ReplaceNetworkAclEntryError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReplaceNetworkAclEntry");
params.put("Version", "2016-11-15");
ReplaceNetworkAclEntryRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ReplaceNetworkAclEntryError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn replace_route(&self, input: ReplaceRouteRequest) -> RusotoFuture<(), ReplaceRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReplaceRoute");
params.put("Version", "2016-11-15");
ReplaceRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ReplaceRouteError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn replace_route_table_association(
&self,
input: ReplaceRouteTableAssociationRequest,
) -> RusotoFuture<ReplaceRouteTableAssociationResult, ReplaceRouteTableAssociationError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReplaceRouteTableAssociation");
params.put("Version", "2016-11-15");
ReplaceRouteTableAssociationRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ReplaceRouteTableAssociationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReplaceRouteTableAssociationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ReplaceRouteTableAssociationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn replace_transit_gateway_route(
&self,
input: ReplaceTransitGatewayRouteRequest,
) -> RusotoFuture<ReplaceTransitGatewayRouteResult, ReplaceTransitGatewayRouteError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReplaceTransitGatewayRoute");
params.put("Version", "2016-11-15");
ReplaceTransitGatewayRouteRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ReplaceTransitGatewayRouteError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReplaceTransitGatewayRouteResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ReplaceTransitGatewayRouteResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn report_instance_status(
&self,
input: ReportInstanceStatusRequest,
) -> RusotoFuture<(), ReportInstanceStatusError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ReportInstanceStatus");
params.put("Version", "2016-11-15");
ReportInstanceStatusRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ReportInstanceStatusError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn request_spot_fleet(
&self,
input: RequestSpotFleetRequest,
) -> RusotoFuture<RequestSpotFleetResponse, RequestSpotFleetError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RequestSpotFleet");
params.put("Version", "2016-11-15");
RequestSpotFleetRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RequestSpotFleetError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RequestSpotFleetResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RequestSpotFleetResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn request_spot_instances(
&self,
input: RequestSpotInstancesRequest,
) -> RusotoFuture<RequestSpotInstancesResult, RequestSpotInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RequestSpotInstances");
params.put("Version", "2016-11-15");
RequestSpotInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(RequestSpotInstancesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RequestSpotInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RequestSpotInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn reset_ebs_default_kms_key_id(
&self,
input: ResetEbsDefaultKmsKeyIdRequest,
) -> RusotoFuture<ResetEbsDefaultKmsKeyIdResult, ResetEbsDefaultKmsKeyIdError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetEbsDefaultKmsKeyId");
params.put("Version", "2016-11-15");
ResetEbsDefaultKmsKeyIdRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ResetEbsDefaultKmsKeyIdError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ResetEbsDefaultKmsKeyIdResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ResetEbsDefaultKmsKeyIdResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn reset_fpga_image_attribute(
&self,
input: ResetFpgaImageAttributeRequest,
) -> RusotoFuture<ResetFpgaImageAttributeResult, ResetFpgaImageAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetFpgaImageAttribute");
params.put("Version", "2016-11-15");
ResetFpgaImageAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ResetFpgaImageAttributeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ResetFpgaImageAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ResetFpgaImageAttributeResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn reset_image_attribute(
&self,
input: ResetImageAttributeRequest,
) -> RusotoFuture<(), ResetImageAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetImageAttribute");
params.put("Version", "2016-11-15");
ResetImageAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ResetImageAttributeError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn reset_instance_attribute(
&self,
input: ResetInstanceAttributeRequest,
) -> RusotoFuture<(), ResetInstanceAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetInstanceAttribute");
params.put("Version", "2016-11-15");
ResetInstanceAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ResetInstanceAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn reset_network_interface_attribute(
&self,
input: ResetNetworkInterfaceAttributeRequest,
) -> RusotoFuture<(), ResetNetworkInterfaceAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetNetworkInterfaceAttribute");
params.put("Version", "2016-11-15");
ResetNetworkInterfaceAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ResetNetworkInterfaceAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn reset_snapshot_attribute(
&self,
input: ResetSnapshotAttributeRequest,
) -> RusotoFuture<(), ResetSnapshotAttributeError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetSnapshotAttribute");
params.put("Version", "2016-11-15");
ResetSnapshotAttributeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ResetSnapshotAttributeError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn restore_address_to_classic(
&self,
input: RestoreAddressToClassicRequest,
) -> RusotoFuture<RestoreAddressToClassicResult, RestoreAddressToClassicError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RestoreAddressToClassic");
params.put("Version", "2016-11-15");
RestoreAddressToClassicRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RestoreAddressToClassicError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RestoreAddressToClassicResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RestoreAddressToClassicResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn revoke_client_vpn_ingress(
&self,
input: RevokeClientVpnIngressRequest,
) -> RusotoFuture<RevokeClientVpnIngressResult, RevokeClientVpnIngressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RevokeClientVpnIngress");
params.put("Version", "2016-11-15");
RevokeClientVpnIngressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RevokeClientVpnIngressError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RevokeClientVpnIngressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RevokeClientVpnIngressResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn revoke_security_group_egress(
&self,
input: RevokeSecurityGroupEgressRequest,
) -> RusotoFuture<(), RevokeSecurityGroupEgressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RevokeSecurityGroupEgress");
params.put("Version", "2016-11-15");
RevokeSecurityGroupEgressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RevokeSecurityGroupEgressError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn revoke_security_group_ingress(
&self,
input: RevokeSecurityGroupIngressRequest,
) -> RusotoFuture<(), RevokeSecurityGroupIngressError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RevokeSecurityGroupIngress");
params.put("Version", "2016-11-15");
RevokeSecurityGroupIngressRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RevokeSecurityGroupIngressError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn run_instances(
&self,
input: RunInstancesRequest,
) -> RusotoFuture<Reservation, RunInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RunInstances");
params.put("Version", "2016-11-15");
RunInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RunInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = Reservation::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ReservationDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn run_scheduled_instances(
&self,
input: RunScheduledInstancesRequest,
) -> RusotoFuture<RunScheduledInstancesResult, RunScheduledInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RunScheduledInstances");
params.put("Version", "2016-11-15");
RunScheduledInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RunScheduledInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RunScheduledInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = RunScheduledInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn search_transit_gateway_routes(
&self,
input: SearchTransitGatewayRoutesRequest,
) -> RusotoFuture<SearchTransitGatewayRoutesResult, SearchTransitGatewayRoutesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "SearchTransitGatewayRoutes");
params.put("Version", "2016-11-15");
SearchTransitGatewayRoutesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(SearchTransitGatewayRoutesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = SearchTransitGatewayRoutesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = SearchTransitGatewayRoutesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn start_instances(
&self,
input: StartInstancesRequest,
) -> RusotoFuture<StartInstancesResult, StartInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "StartInstances");
params.put("Version", "2016-11-15");
StartInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = StartInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = StartInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn stop_instances(
&self,
input: StopInstancesRequest,
) -> RusotoFuture<StopInstancesResult, StopInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "StopInstances");
params.put("Version", "2016-11-15");
StopInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = StopInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
StopInstancesResultDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn terminate_client_vpn_connections(
&self,
input: TerminateClientVpnConnectionsRequest,
) -> RusotoFuture<TerminateClientVpnConnectionsResult, TerminateClientVpnConnectionsError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "TerminateClientVpnConnections");
params.put("Version", "2016-11-15");
TerminateClientVpnConnectionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(TerminateClientVpnConnectionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TerminateClientVpnConnectionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = TerminateClientVpnConnectionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn terminate_instances(
&self,
input: TerminateInstancesRequest,
) -> RusotoFuture<TerminateInstancesResult, TerminateInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "TerminateInstances");
params.put("Version", "2016-11-15");
TerminateInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TerminateInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TerminateInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = TerminateInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn unassign_ipv_6_addresses(
&self,
input: UnassignIpv6AddressesRequest,
) -> RusotoFuture<UnassignIpv6AddressesResult, UnassignIpv6AddressesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UnassignIpv6Addresses");
params.put("Version", "2016-11-15");
UnassignIpv6AddressesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UnassignIpv6AddressesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UnassignIpv6AddressesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = UnassignIpv6AddressesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn unassign_private_ip_addresses(
&self,
input: UnassignPrivateIpAddressesRequest,
) -> RusotoFuture<(), UnassignPrivateIpAddressesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UnassignPrivateIpAddresses");
params.put("Version", "2016-11-15");
UnassignPrivateIpAddressesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UnassignPrivateIpAddressesError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn unmonitor_instances(
&self,
input: UnmonitorInstancesRequest,
) -> RusotoFuture<UnmonitorInstancesResult, UnmonitorInstancesError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UnmonitorInstances");
params.put("Version", "2016-11-15");
UnmonitorInstancesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UnmonitorInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UnmonitorInstancesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = UnmonitorInstancesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn update_security_group_rule_descriptions_egress(
&self,
input: UpdateSecurityGroupRuleDescriptionsEgressRequest,
) -> RusotoFuture<
UpdateSecurityGroupRuleDescriptionsEgressResult,
UpdateSecurityGroupRuleDescriptionsEgressError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UpdateSecurityGroupRuleDescriptionsEgress");
params.put("Version", "2016-11-15");
UpdateSecurityGroupRuleDescriptionsEgressRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateSecurityGroupRuleDescriptionsEgressError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UpdateSecurityGroupRuleDescriptionsEgressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
UpdateSecurityGroupRuleDescriptionsEgressResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn update_security_group_rule_descriptions_ingress(
&self,
input: UpdateSecurityGroupRuleDescriptionsIngressRequest,
) -> RusotoFuture<
UpdateSecurityGroupRuleDescriptionsIngressResult,
UpdateSecurityGroupRuleDescriptionsIngressError,
> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UpdateSecurityGroupRuleDescriptionsIngress");
params.put("Version", "2016-11-15");
UpdateSecurityGroupRuleDescriptionsIngressRequestSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateSecurityGroupRuleDescriptionsIngressError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UpdateSecurityGroupRuleDescriptionsIngressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
UpdateSecurityGroupRuleDescriptionsIngressResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
fn withdraw_byoip_cidr(
&self,
input: WithdrawByoipCidrRequest,
) -> RusotoFuture<WithdrawByoipCidrResult, WithdrawByoipCidrError> {
let mut request = SignedRequest::new("POST", "ec2", &self.region, "/");
let mut params = Params::new();
params.put("Action", "WithdrawByoipCidr");
params.put("Version", "2016-11-15");
WithdrawByoipCidrRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(WithdrawByoipCidrError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = WithdrawByoipCidrResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_ref(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = WithdrawByoipCidrResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[test]
fn test_parse_error_ec_2_describe_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/error",
"ec2-describe-instances.xml",
);
let mock = MockRequestDispatcher::with_status(400).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeInstancesRequest::default();
let result = client.describe_instances(request).sync();
assert!(!result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_allocate_address() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-allocate-address.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AllocateAddressRequest::default();
let result = client.allocate_address(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_assign_private_ip_addresses() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-assign-private-ip-addresses.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AssignPrivateIpAddressesRequest::default();
let result = client.assign_private_ip_addresses(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_associate_address() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-associate-address.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AssociateAddressRequest::default();
let result = client.associate_address(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_associate_route_table() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-associate-route-table.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AssociateRouteTableRequest::default();
let result = client.associate_route_table(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_attach_volume() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-attach-volume.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AttachVolumeRequest::default();
let result = client.attach_volume(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_attach_vpn_gateway() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-attach-vpn-gateway.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AttachVpnGatewayRequest::default();
let result = client.attach_vpn_gateway(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_bundle_instance() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-bundle-instance.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = BundleInstanceRequest::default();
let result = client.bundle_instance(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_cancel_bundle_task() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-cancel-bundle-task.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CancelBundleTaskRequest::default();
let result = client.cancel_bundle_task(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_cancel_reserved_instances_listing() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-cancel-reserved-instances-listing.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CancelReservedInstancesListingRequest::default();
let result = client.cancel_reserved_instances_listing(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_cancel_spot_instance_requests() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-cancel-spot-instance-requests.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CancelSpotInstanceRequestsRequest::default();
let result = client.cancel_spot_instance_requests(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_confirm_product_instance() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-confirm-product-instance.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ConfirmProductInstanceRequest::default();
let result = client.confirm_product_instance(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_copy_snapshot() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-copy-snapshot.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CopySnapshotRequest::default();
let result = client.copy_snapshot(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_customer_gateway() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-customer-gateway.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateCustomerGatewayRequest::default();
let result = client.create_customer_gateway(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_dhcp_options() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-dhcp-options.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateDhcpOptionsRequest::default();
let result = client.create_dhcp_options(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_instance_export_task() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-instance-export-task.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateInstanceExportTaskRequest::default();
let result = client.create_instance_export_task(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_key_pair() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-key-pair.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateKeyPairRequest::default();
let result = client.create_key_pair(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_network_acl() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-network-acl.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateNetworkAclRequest::default();
let result = client.create_network_acl(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_network_interface() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-network-interface.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateNetworkInterfaceRequest::default();
let result = client.create_network_interface(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_reserved_instances_listing() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-reserved-instances-listing.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateReservedInstancesListingRequest::default();
let result = client.create_reserved_instances_listing(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_route_table() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-route-table.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateRouteTableRequest::default();
let result = client.create_route_table(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_snapshot() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-snapshot.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateSnapshotRequest::default();
let result = client.create_snapshot(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_spot_datafeed_subscription() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-spot-datafeed-subscription.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateSpotDatafeedSubscriptionRequest::default();
let result = client.create_spot_datafeed_subscription(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_subnet() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-subnet.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateSubnetRequest::default();
let result = client.create_subnet(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_volume() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-volume.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateVolumeRequest::default();
let result = client.create_volume(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_vpc() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-vpc.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateVpcRequest::default();
let result = client.create_vpc(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_create_vpn_gateway() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-create-vpn-gateway.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateVpnGatewayRequest::default();
let result = client.create_vpn_gateway(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_delete_internet_gateway() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-delete-internet-gateway.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DeleteInternetGatewayRequest::default();
let result = client.delete_internet_gateway(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_account_attributes() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-account-attributes.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAccountAttributesRequest::default();
let result = client.describe_account_attributes(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_addresses() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-addresses.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAddressesRequest::default();
let result = client.describe_addresses(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_availability_zones() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-availability-zones.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAvailabilityZonesRequest::default();
let result = client.describe_availability_zones(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_bundle_tasks() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-bundle-tasks.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeBundleTasksRequest::default();
let result = client.describe_bundle_tasks(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_customer_gateways() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-customer-gateways.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeCustomerGatewaysRequest::default();
let result = client.describe_customer_gateways(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_dhcp_options() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-dhcp-options.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeDhcpOptionsRequest::default();
let result = client.describe_dhcp_options(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_export_tasks() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-export-tasks.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeExportTasksRequest::default();
let result = client.describe_export_tasks(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_instance_attribute() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-instance-attribute.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeInstanceAttributeRequest::default();
let result = client.describe_instance_attribute(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_instance_status() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-instance-status.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeInstanceStatusRequest::default();
let result = client.describe_instance_status(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeInstancesRequest::default();
let result = client.describe_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_internet_gateways() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-internet-gateways.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeInternetGatewaysRequest::default();
let result = client.describe_internet_gateways(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_key_pairs() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-key-pairs.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeKeyPairsRequest::default();
let result = client.describe_key_pairs(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_network_acls() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-network-acls.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeNetworkAclsRequest::default();
let result = client.describe_network_acls(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_network_interfaces() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-network-interfaces.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeNetworkInterfacesRequest::default();
let result = client.describe_network_interfaces(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_placement_groups() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-placement-groups.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribePlacementGroupsRequest::default();
let result = client.describe_placement_groups(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_regions() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-regions.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeRegionsRequest::default();
let result = client.describe_regions(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_reserved_instances_offerings() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-reserved-instances-offerings.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeReservedInstancesOfferingsRequest::default();
let result = client.describe_reserved_instances_offerings(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_reserved_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-reserved-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeReservedInstancesRequest::default();
let result = client.describe_reserved_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_route_tables() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-route-tables.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeRouteTablesRequest::default();
let result = client.describe_route_tables(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_security_groups() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-security-groups.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeSecurityGroupsRequest::default();
let result = client.describe_security_groups(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_snapshots() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-snapshots.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeSnapshotsRequest::default();
let result = client.describe_snapshots(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_spot_instance_requests() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-spot-instance-requests.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeSpotInstanceRequestsRequest::default();
let result = client.describe_spot_instance_requests(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_spot_price_history() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-spot-price-history.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeSpotPriceHistoryRequest::default();
let result = client.describe_spot_price_history(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_subnets() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-subnets.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeSubnetsRequest::default();
let result = client.describe_subnets(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_tags() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-tags.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeTagsRequest::default();
let result = client.describe_tags(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_volume_status() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-volume-status.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeVolumeStatusRequest::default();
let result = client.describe_volume_status(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_volumes() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-volumes.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeVolumesRequest::default();
let result = client.describe_volumes(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_vpcs() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-vpcs.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeVpcsRequest::default();
let result = client.describe_vpcs(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_vpn_connections() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-vpn-connections.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeVpnConnectionsRequest::default();
let result = client.describe_vpn_connections(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_describe_vpn_gateways() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-describe-vpn-gateways.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeVpnGatewaysRequest::default();
let result = client.describe_vpn_gateways(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_detach_network_interface() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-detach-network-interface.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DetachNetworkInterfaceRequest::default();
let result = client.detach_network_interface(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_detach_volume() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-detach-volume.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DetachVolumeRequest::default();
let result = client.detach_volume(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_get_password_data() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-get-password-data.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetPasswordDataRequest::default();
let result = client.get_password_data(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_import_instance() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-import-instance.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ImportInstanceRequest::default();
let result = client.import_instance(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_import_key_pair() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-import-key-pair.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ImportKeyPairRequest::default();
let result = client.import_key_pair(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_import_volume() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-import-volume.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ImportVolumeRequest::default();
let result = client.import_volume(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_modify_snapshot_attribute() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-modify-snapshot-attribute.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ModifySnapshotAttributeRequest::default();
let result = client.modify_snapshot_attribute(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_monitor_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-monitor-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = MonitorInstancesRequest::default();
let result = client.monitor_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_register_image() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-register-image.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = RegisterImageRequest::default();
let result = client.register_image(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_replace_network_acl_association() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-replace-network-acl-association.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ReplaceNetworkAclAssociationRequest::default();
let result = client.replace_network_acl_association(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_request_spot_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-request-spot-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = RequestSpotInstancesRequest::default();
let result = client.request_spot_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_run_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-run-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = RunInstancesRequest::default();
let result = client.run_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_start_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-start-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = StartInstancesRequest::default();
let result = client.start_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_stop_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-stop-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = StopInstancesRequest::default();
let result = client.stop_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_ec_2_unmonitor_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"ec2-unmonitor-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = Ec2Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = UnmonitorInstancesRequest::default();
let result = client.unmonitor_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
}