use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto::xml::error::*;
use rusoto_core::proto::xml::util::{
self as xml_util, deserialize_elements, find_start_element, skip_tree,
};
use rusoto_core::proto::xml::util::{Next, Peek, XmlParseError, XmlResponse};
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[cfg(feature = "deserialize_structs")]
use serde::Deserialize;
#[cfg(feature = "serialize_structs")]
use serde::Serialize;
use serde_urlencoded;
use std::str::FromStr;
use xml::EventReader;
impl CloudFormationClient {
fn new_params(&self, operation_name: &str) -> Params {
let mut params = Params::new();
params.put("Action", operation_name);
params.put("Version", "2010-05-15");
params
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
#[allow(dead_code)]
struct AccountDeserializer;
impl AccountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AccountGateResult {
pub status: Option<String>,
pub status_reason: Option<String>,
}
#[allow(dead_code)]
struct AccountGateResultDeserializer;
impl AccountGateResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountGateResult, XmlParseError> {
deserialize_elements::<_, AccountGateResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Status" => {
obj.status = Some(AccountGateStatusDeserializer::deserialize("Status", stack)?);
}
"StatusReason" => {
obj.status_reason = Some(AccountGateStatusReasonDeserializer::deserialize(
"StatusReason",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AccountGateStatusDeserializer;
impl AccountGateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AccountGateStatusReasonDeserializer;
impl AccountGateStatusReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AccountLimit {
pub name: Option<String>,
pub value: Option<i64>,
}
#[allow(dead_code)]
struct AccountLimitDeserializer;
impl AccountLimitDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountLimit, XmlParseError> {
deserialize_elements::<_, AccountLimit, _>(tag_name, stack, |name, stack, obj| {
match name {
"Name" => {
obj.name = Some(LimitNameDeserializer::deserialize("Name", stack)?);
}
"Value" => {
obj.value = Some(LimitValueDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AccountLimitListDeserializer;
impl AccountLimitListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AccountLimit>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(AccountLimitDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AccountListDeserializer;
impl AccountListDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(AccountDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct AccountListSerializer;
impl AccountListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct AllowedValueDeserializer;
impl AllowedValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AllowedValuesDeserializer;
impl AllowedValuesDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(AllowedValueDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ArnDeserializer;
impl ArnDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AutoDeployment {
pub enabled: Option<bool>,
pub retain_stacks_on_account_removal: Option<bool>,
}
#[allow(dead_code)]
struct AutoDeploymentDeserializer;
impl AutoDeploymentDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AutoDeployment, XmlParseError> {
deserialize_elements::<_, AutoDeployment, _>(tag_name, stack, |name, stack, obj| {
match name {
"Enabled" => {
obj.enabled = Some(AutoDeploymentNullableDeserializer::deserialize(
"Enabled", stack,
)?);
}
"RetainStacksOnAccountRemoval" => {
obj.retain_stacks_on_account_removal = Some(
RetainStacksOnAccountRemovalNullableDeserializer::deserialize(
"RetainStacksOnAccountRemoval",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AutoDeploymentSerializer;
impl AutoDeploymentSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AutoDeployment) {
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);
}
if let Some(ref field_value) = obj.retain_stacks_on_account_removal {
params.put(
&format!("{}{}", prefix, "RetainStacksOnAccountRemoval"),
&field_value,
);
}
}
}
#[allow(dead_code)]
struct AutoDeploymentNullableDeserializer;
impl AutoDeploymentNullableDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct BoxedIntegerDeserializer;
impl BoxedIntegerDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelUpdateStackInput {
pub client_request_token: Option<String>,
pub stack_name: String,
}
struct CancelUpdateStackInputSerializer;
impl CancelUpdateStackInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelUpdateStackInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[allow(dead_code)]
struct CapabilitiesDeserializer;
impl CapabilitiesDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(CapabilityDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct CapabilitiesSerializer;
impl CapabilitiesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct CapabilitiesReasonDeserializer;
impl CapabilitiesReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct CapabilityDeserializer;
impl CapabilityDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct CausingEntityDeserializer;
impl CausingEntityDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Change {
pub resource_change: Option<ResourceChange>,
pub type_: Option<String>,
}
#[allow(dead_code)]
struct ChangeDeserializer;
impl ChangeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Change, XmlParseError> {
deserialize_elements::<_, Change, _>(tag_name, stack, |name, stack, obj| {
match name {
"ResourceChange" => {
obj.resource_change = Some(ResourceChangeDeserializer::deserialize(
"ResourceChange",
stack,
)?);
}
"Type" => {
obj.type_ = Some(ChangeTypeDeserializer::deserialize("Type", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ChangeActionDeserializer;
impl ChangeActionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangeSetIdDeserializer;
impl ChangeSetIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangeSetNameDeserializer;
impl ChangeSetNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangeSetStatusDeserializer;
impl ChangeSetStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangeSetStatusReasonDeserializer;
impl ChangeSetStatusReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangeSetSummariesDeserializer;
impl ChangeSetSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ChangeSetSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ChangeSetSummaryDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ChangeSetSummary {
pub change_set_id: Option<String>,
pub change_set_name: Option<String>,
pub creation_time: Option<String>,
pub description: Option<String>,
pub execution_status: Option<String>,
pub stack_id: Option<String>,
pub stack_name: Option<String>,
pub status: Option<String>,
pub status_reason: Option<String>,
}
#[allow(dead_code)]
struct ChangeSetSummaryDeserializer;
impl ChangeSetSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ChangeSetSummary, XmlParseError> {
deserialize_elements::<_, ChangeSetSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"ChangeSetId" => {
obj.change_set_id =
Some(ChangeSetIdDeserializer::deserialize("ChangeSetId", stack)?);
}
"ChangeSetName" => {
obj.change_set_name = Some(ChangeSetNameDeserializer::deserialize(
"ChangeSetName",
stack,
)?);
}
"CreationTime" => {
obj.creation_time = Some(CreationTimeDeserializer::deserialize(
"CreationTime",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"ExecutionStatus" => {
obj.execution_status = Some(ExecutionStatusDeserializer::deserialize(
"ExecutionStatus",
stack,
)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackName" => {
obj.stack_name = Some(StackNameDeserializer::deserialize("StackName", stack)?);
}
"Status" => {
obj.status = Some(ChangeSetStatusDeserializer::deserialize("Status", stack)?);
}
"StatusReason" => {
obj.status_reason = Some(ChangeSetStatusReasonDeserializer::deserialize(
"StatusReason",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ChangeSourceDeserializer;
impl ChangeSourceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangeTypeDeserializer;
impl ChangeTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ChangesDeserializer;
impl ChangesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Change>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ChangeDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClientRequestTokenDeserializer;
impl ClientRequestTokenDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContinueUpdateRollbackInput {
pub client_request_token: Option<String>,
pub resources_to_skip: Option<Vec<String>>,
pub role_arn: Option<String>,
pub stack_name: String,
}
struct ContinueUpdateRollbackInputSerializer;
impl ContinueUpdateRollbackInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ContinueUpdateRollbackInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.resources_to_skip {
ResourcesToSkipSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourcesToSkip"),
field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ContinueUpdateRollbackOutput {}
#[allow(dead_code)]
struct ContinueUpdateRollbackOutputDeserializer;
impl ContinueUpdateRollbackOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ContinueUpdateRollbackOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = ContinueUpdateRollbackOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateChangeSetInput {
pub capabilities: Option<Vec<String>>,
pub change_set_name: String,
pub change_set_type: Option<String>,
pub client_token: Option<String>,
pub description: Option<String>,
pub notification_ar_ns: Option<Vec<String>>,
pub parameters: Option<Vec<Parameter>>,
pub resource_types: Option<Vec<String>>,
pub resources_to_import: Option<Vec<ResourceToImport>>,
pub role_arn: Option<String>,
pub rollback_configuration: Option<RollbackConfiguration>,
pub stack_name: String,
pub tags: Option<Vec<Tag>>,
pub template_body: Option<String>,
pub template_url: Option<String>,
pub use_previous_template: Option<bool>,
}
struct CreateChangeSetInputSerializer;
impl CreateChangeSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateChangeSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capabilities {
CapabilitiesSerializer::serialize(
params,
&format!("{}{}", prefix, "Capabilities"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ChangeSetName"),
&obj.change_set_name,
);
if let Some(ref field_value) = obj.change_set_type {
params.put(&format!("{}{}", prefix, "ChangeSetType"), &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.notification_ar_ns {
NotificationARNsSerializer::serialize(
params,
&format!("{}{}", prefix, "NotificationARNs"),
field_value,
);
}
if let Some(ref field_value) = obj.parameters {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameters"),
field_value,
);
}
if let Some(ref field_value) = obj.resource_types {
ResourceTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceTypes"),
field_value,
);
}
if let Some(ref field_value) = obj.resources_to_import {
ResourcesToImportSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourcesToImport"),
field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
if let Some(ref field_value) = obj.rollback_configuration {
RollbackConfigurationSerializer::serialize(
params,
&format!("{}{}", prefix, "RollbackConfiguration"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
if let Some(ref field_value) = obj.tags {
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
if let Some(ref field_value) = obj.use_previous_template {
params.put(
&format!("{}{}", prefix, "UsePreviousTemplate"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateChangeSetOutput {
pub id: Option<String>,
pub stack_id: Option<String>,
}
#[allow(dead_code)]
struct CreateChangeSetOutputDeserializer;
impl CreateChangeSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateChangeSetOutput, XmlParseError> {
deserialize_elements::<_, CreateChangeSetOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Id" => {
obj.id = Some(ChangeSetIdDeserializer::deserialize("Id", stack)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStackInput {
pub capabilities: Option<Vec<String>>,
pub client_request_token: Option<String>,
pub disable_rollback: Option<bool>,
pub enable_termination_protection: Option<bool>,
pub notification_ar_ns: Option<Vec<String>>,
pub on_failure: Option<String>,
pub parameters: Option<Vec<Parameter>>,
pub resource_types: Option<Vec<String>>,
pub role_arn: Option<String>,
pub rollback_configuration: Option<RollbackConfiguration>,
pub stack_name: String,
pub stack_policy_body: Option<String>,
pub stack_policy_url: Option<String>,
pub tags: Option<Vec<Tag>>,
pub template_body: Option<String>,
pub template_url: Option<String>,
pub timeout_in_minutes: Option<i64>,
}
struct CreateStackInputSerializer;
impl CreateStackInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateStackInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capabilities {
CapabilitiesSerializer::serialize(
params,
&format!("{}{}", prefix, "Capabilities"),
field_value,
);
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.disable_rollback {
params.put(&format!("{}{}", prefix, "DisableRollback"), &field_value);
}
if let Some(ref field_value) = obj.enable_termination_protection {
params.put(
&format!("{}{}", prefix, "EnableTerminationProtection"),
&field_value,
);
}
if let Some(ref field_value) = obj.notification_ar_ns {
NotificationARNsSerializer::serialize(
params,
&format!("{}{}", prefix, "NotificationARNs"),
field_value,
);
}
if let Some(ref field_value) = obj.on_failure {
params.put(&format!("{}{}", prefix, "OnFailure"), &field_value);
}
if let Some(ref field_value) = obj.parameters {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameters"),
field_value,
);
}
if let Some(ref field_value) = obj.resource_types {
ResourceTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceTypes"),
field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
if let Some(ref field_value) = obj.rollback_configuration {
RollbackConfigurationSerializer::serialize(
params,
&format!("{}{}", prefix, "RollbackConfiguration"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
if let Some(ref field_value) = obj.stack_policy_body {
params.put(&format!("{}{}", prefix, "StackPolicyBody"), &field_value);
}
if let Some(ref field_value) = obj.stack_policy_url {
params.put(&format!("{}{}", prefix, "StackPolicyURL"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
if let Some(ref field_value) = obj.timeout_in_minutes {
params.put(&format!("{}{}", prefix, "TimeoutInMinutes"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStackInstancesInput {
pub accounts: Option<Vec<String>>,
pub deployment_targets: Option<DeploymentTargets>,
pub operation_id: Option<String>,
pub operation_preferences: Option<StackSetOperationPreferences>,
pub parameter_overrides: Option<Vec<Parameter>>,
pub regions: Vec<String>,
pub stack_set_name: String,
}
struct CreateStackInstancesInputSerializer;
impl CreateStackInstancesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateStackInstancesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.accounts {
AccountListSerializer::serialize(
params,
&format!("{}{}", prefix, "Accounts"),
field_value,
);
}
if let Some(ref field_value) = obj.deployment_targets {
DeploymentTargetsSerializer::serialize(
params,
&format!("{}{}", prefix, "DeploymentTargets"),
field_value,
);
}
if let Some(ref field_value) = obj.operation_id {
params.put(&format!("{}{}", prefix, "OperationId"), &field_value);
}
if let Some(ref field_value) = obj.operation_preferences {
StackSetOperationPreferencesSerializer::serialize(
params,
&format!("{}{}", prefix, "OperationPreferences"),
field_value,
);
}
if let Some(ref field_value) = obj.parameter_overrides {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "ParameterOverrides"),
field_value,
);
}
RegionListSerializer::serialize(params, &format!("{}{}", prefix, "Regions"), &obj.regions);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateStackInstancesOutput {
pub operation_id: Option<String>,
}
#[allow(dead_code)]
struct CreateStackInstancesOutputDeserializer;
impl CreateStackInstancesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStackInstancesOutput, XmlParseError> {
deserialize_elements::<_, CreateStackInstancesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateStackOutput {
pub stack_id: Option<String>,
}
#[allow(dead_code)]
struct CreateStackOutputDeserializer;
impl CreateStackOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStackOutput, XmlParseError> {
deserialize_elements::<_, CreateStackOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStackSetInput {
pub administration_role_arn: Option<String>,
pub auto_deployment: Option<AutoDeployment>,
pub capabilities: Option<Vec<String>>,
pub client_request_token: Option<String>,
pub description: Option<String>,
pub execution_role_name: Option<String>,
pub parameters: Option<Vec<Parameter>>,
pub permission_model: Option<String>,
pub stack_set_name: String,
pub tags: Option<Vec<Tag>>,
pub template_body: Option<String>,
pub template_url: Option<String>,
}
struct CreateStackSetInputSerializer;
impl CreateStackSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateStackSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.administration_role_arn {
params.put(
&format!("{}{}", prefix, "AdministrationRoleARN"),
&field_value,
);
}
if let Some(ref field_value) = obj.auto_deployment {
AutoDeploymentSerializer::serialize(
params,
&format!("{}{}", prefix, "AutoDeployment"),
field_value,
);
}
if let Some(ref field_value) = obj.capabilities {
CapabilitiesSerializer::serialize(
params,
&format!("{}{}", prefix, "Capabilities"),
field_value,
);
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.execution_role_name {
params.put(&format!("{}{}", prefix, "ExecutionRoleName"), &field_value);
}
if let Some(ref field_value) = obj.parameters {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameters"),
field_value,
);
}
if let Some(ref field_value) = obj.permission_model {
params.put(&format!("{}{}", prefix, "PermissionModel"), &field_value);
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
if let Some(ref field_value) = obj.tags {
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateStackSetOutput {
pub stack_set_id: Option<String>,
}
#[allow(dead_code)]
struct CreateStackSetOutputDeserializer;
impl CreateStackSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStackSetOutput, XmlParseError> {
deserialize_elements::<_, CreateStackSetOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StackSetId" => {
obj.stack_set_id =
Some(StackSetIdDeserializer::deserialize("StackSetId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct CreationTimeDeserializer;
impl CreationTimeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteChangeSetInput {
pub change_set_name: String,
pub stack_name: Option<String>,
}
struct DeleteChangeSetInputSerializer;
impl DeleteChangeSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteChangeSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ChangeSetName"),
&obj.change_set_name,
);
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteChangeSetOutput {}
#[allow(dead_code)]
struct DeleteChangeSetOutputDeserializer;
impl DeleteChangeSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteChangeSetOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = DeleteChangeSetOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteStackInput {
pub client_request_token: Option<String>,
pub retain_resources: Option<Vec<String>>,
pub role_arn: Option<String>,
pub stack_name: String,
}
struct DeleteStackInputSerializer;
impl DeleteStackInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteStackInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.retain_resources {
RetainResourcesSerializer::serialize(
params,
&format!("{}{}", prefix, "RetainResources"),
field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteStackInstancesInput {
pub accounts: Option<Vec<String>>,
pub deployment_targets: Option<DeploymentTargets>,
pub operation_id: Option<String>,
pub operation_preferences: Option<StackSetOperationPreferences>,
pub regions: Vec<String>,
pub retain_stacks: bool,
pub stack_set_name: String,
}
struct DeleteStackInstancesInputSerializer;
impl DeleteStackInstancesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteStackInstancesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.accounts {
AccountListSerializer::serialize(
params,
&format!("{}{}", prefix, "Accounts"),
field_value,
);
}
if let Some(ref field_value) = obj.deployment_targets {
DeploymentTargetsSerializer::serialize(
params,
&format!("{}{}", prefix, "DeploymentTargets"),
field_value,
);
}
if let Some(ref field_value) = obj.operation_id {
params.put(&format!("{}{}", prefix, "OperationId"), &field_value);
}
if let Some(ref field_value) = obj.operation_preferences {
StackSetOperationPreferencesSerializer::serialize(
params,
&format!("{}{}", prefix, "OperationPreferences"),
field_value,
);
}
RegionListSerializer::serialize(params, &format!("{}{}", prefix, "Regions"), &obj.regions);
params.put(&format!("{}{}", prefix, "RetainStacks"), &obj.retain_stacks);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteStackInstancesOutput {
pub operation_id: Option<String>,
}
#[allow(dead_code)]
struct DeleteStackInstancesOutputDeserializer;
impl DeleteStackInstancesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteStackInstancesOutput, XmlParseError> {
deserialize_elements::<_, DeleteStackInstancesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteStackSetInput {
pub stack_set_name: String,
}
struct DeleteStackSetInputSerializer;
impl DeleteStackSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteStackSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteStackSetOutput {}
#[allow(dead_code)]
struct DeleteStackSetOutputDeserializer;
impl DeleteStackSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteStackSetOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = DeleteStackSetOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct DeletionTimeDeserializer;
impl DeletionTimeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeploymentTargets {
pub accounts: Option<Vec<String>>,
pub organizational_unit_ids: Option<Vec<String>>,
}
#[allow(dead_code)]
struct DeploymentTargetsDeserializer;
impl DeploymentTargetsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeploymentTargets, XmlParseError> {
deserialize_elements::<_, DeploymentTargets, _>(tag_name, stack, |name, stack, obj| {
match name {
"Accounts" => {
obj.accounts
.get_or_insert(vec![])
.extend(AccountListDeserializer::deserialize("Accounts", stack)?);
}
"OrganizationalUnitIds" => {
obj.organizational_unit_ids.get_or_insert(vec![]).extend(
OrganizationalUnitIdListDeserializer::deserialize(
"OrganizationalUnitIds",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DeploymentTargetsSerializer;
impl DeploymentTargetsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeploymentTargets) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.accounts {
AccountListSerializer::serialize(
params,
&format!("{}{}", prefix, "Accounts"),
field_value,
);
}
if let Some(ref field_value) = obj.organizational_unit_ids {
OrganizationalUnitIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "OrganizationalUnitIds"),
field_value,
);
}
}
}
#[allow(dead_code)]
struct DeprecatedStatusDeserializer;
impl DeprecatedStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterTypeInput {
pub arn: Option<String>,
pub type_: Option<String>,
pub type_name: Option<String>,
pub version_id: Option<String>,
}
struct DeregisterTypeInputSerializer;
impl DeregisterTypeInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeregisterTypeInput) {
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.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.type_name {
params.put(&format!("{}{}", prefix, "TypeName"), &field_value);
}
if let Some(ref field_value) = obj.version_id {
params.put(&format!("{}{}", prefix, "VersionId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeregisterTypeOutput {}
#[allow(dead_code)]
struct DeregisterTypeOutputDeserializer;
impl DeregisterTypeOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeregisterTypeOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = DeregisterTypeOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAccountLimitsInput {
pub next_token: Option<String>,
}
struct DescribeAccountLimitsInputSerializer;
impl DescribeAccountLimitsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAccountLimitsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAccountLimitsOutput {
pub account_limits: Option<Vec<AccountLimit>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct DescribeAccountLimitsOutputDeserializer;
impl DescribeAccountLimitsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAccountLimitsOutput, XmlParseError> {
deserialize_elements::<_, DescribeAccountLimitsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AccountLimits" => {
obj.account_limits.get_or_insert(vec![]).extend(
AccountLimitListDeserializer::deserialize("AccountLimits", stack)?,
);
}
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeChangeSetInput {
pub change_set_name: String,
pub next_token: Option<String>,
pub stack_name: Option<String>,
}
struct DescribeChangeSetInputSerializer;
impl DescribeChangeSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeChangeSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ChangeSetName"),
&obj.change_set_name,
);
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeChangeSetOutput {
pub capabilities: Option<Vec<String>>,
pub change_set_id: Option<String>,
pub change_set_name: Option<String>,
pub changes: Option<Vec<Change>>,
pub creation_time: Option<String>,
pub description: Option<String>,
pub execution_status: Option<String>,
pub next_token: Option<String>,
pub notification_ar_ns: Option<Vec<String>>,
pub parameters: Option<Vec<Parameter>>,
pub rollback_configuration: Option<RollbackConfiguration>,
pub stack_id: Option<String>,
pub stack_name: Option<String>,
pub status: Option<String>,
pub status_reason: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct DescribeChangeSetOutputDeserializer;
impl DescribeChangeSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeChangeSetOutput, XmlParseError> {
deserialize_elements::<_, DescribeChangeSetOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Capabilities" => {
obj.capabilities.get_or_insert(vec![]).extend(
CapabilitiesDeserializer::deserialize("Capabilities", stack)?,
);
}
"ChangeSetId" => {
obj.change_set_id =
Some(ChangeSetIdDeserializer::deserialize("ChangeSetId", stack)?);
}
"ChangeSetName" => {
obj.change_set_name = Some(ChangeSetNameDeserializer::deserialize(
"ChangeSetName",
stack,
)?);
}
"Changes" => {
obj.changes
.get_or_insert(vec![])
.extend(ChangesDeserializer::deserialize("Changes", stack)?);
}
"CreationTime" => {
obj.creation_time = Some(CreationTimeDeserializer::deserialize(
"CreationTime",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"ExecutionStatus" => {
obj.execution_status = Some(ExecutionStatusDeserializer::deserialize(
"ExecutionStatus",
stack,
)?);
}
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"NotificationARNs" => {
obj.notification_ar_ns.get_or_insert(vec![]).extend(
NotificationARNsDeserializer::deserialize("NotificationARNs", stack)?,
);
}
"Parameters" => {
obj.parameters
.get_or_insert(vec![])
.extend(ParametersDeserializer::deserialize("Parameters", stack)?);
}
"RollbackConfiguration" => {
obj.rollback_configuration =
Some(RollbackConfigurationDeserializer::deserialize(
"RollbackConfiguration",
stack,
)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackName" => {
obj.stack_name =
Some(StackNameDeserializer::deserialize("StackName", stack)?);
}
"Status" => {
obj.status =
Some(ChangeSetStatusDeserializer::deserialize("Status", stack)?);
}
"StatusReason" => {
obj.status_reason = Some(ChangeSetStatusReasonDeserializer::deserialize(
"StatusReason",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagsDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackDriftDetectionStatusInput {
pub stack_drift_detection_id: String,
}
struct DescribeStackDriftDetectionStatusInputSerializer;
impl DescribeStackDriftDetectionStatusInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackDriftDetectionStatusInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "StackDriftDetectionId"),
&obj.stack_drift_detection_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackDriftDetectionStatusOutput {
pub detection_status: String,
pub detection_status_reason: Option<String>,
pub drifted_stack_resource_count: Option<i64>,
pub stack_drift_detection_id: String,
pub stack_drift_status: Option<String>,
pub stack_id: String,
pub timestamp: String,
}
#[allow(dead_code)]
struct DescribeStackDriftDetectionStatusOutputDeserializer;
impl DescribeStackDriftDetectionStatusOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackDriftDetectionStatusOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackDriftDetectionStatusOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DetectionStatus" => {
obj.detection_status = StackDriftDetectionStatusDeserializer::deserialize(
"DetectionStatus",
stack,
)?;
}
"DetectionStatusReason" => {
obj.detection_status_reason =
Some(StackDriftDetectionStatusReasonDeserializer::deserialize(
"DetectionStatusReason",
stack,
)?);
}
"DriftedStackResourceCount" => {
obj.drifted_stack_resource_count =
Some(BoxedIntegerDeserializer::deserialize(
"DriftedStackResourceCount",
stack,
)?);
}
"StackDriftDetectionId" => {
obj.stack_drift_detection_id =
StackDriftDetectionIdDeserializer::deserialize(
"StackDriftDetectionId",
stack,
)?;
}
"StackDriftStatus" => {
obj.stack_drift_status = Some(StackDriftStatusDeserializer::deserialize(
"StackDriftStatus",
stack,
)?);
}
"StackId" => {
obj.stack_id = StackIdDeserializer::deserialize("StackId", stack)?;
}
"Timestamp" => {
obj.timestamp = TimestampDeserializer::deserialize("Timestamp", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackEventsInput {
pub next_token: Option<String>,
pub stack_name: Option<String>,
}
struct DescribeStackEventsInputSerializer;
impl DescribeStackEventsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackEventsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackEventsOutput {
pub next_token: Option<String>,
pub stack_events: Option<Vec<StackEvent>>,
}
#[allow(dead_code)]
struct DescribeStackEventsOutputDeserializer;
impl DescribeStackEventsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackEventsOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackEventsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"StackEvents" => {
obj.stack_events
.get_or_insert(vec![])
.extend(StackEventsDeserializer::deserialize("StackEvents", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackInstanceInput {
pub stack_instance_account: String,
pub stack_instance_region: String,
pub stack_set_name: String,
}
struct DescribeStackInstanceInputSerializer;
impl DescribeStackInstanceInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackInstanceInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "StackInstanceAccount"),
&obj.stack_instance_account,
);
params.put(
&format!("{}{}", prefix, "StackInstanceRegion"),
&obj.stack_instance_region,
);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackInstanceOutput {
pub stack_instance: Option<StackInstance>,
}
#[allow(dead_code)]
struct DescribeStackInstanceOutputDeserializer;
impl DescribeStackInstanceOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackInstanceOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackInstanceOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StackInstance" => {
obj.stack_instance = Some(StackInstanceDeserializer::deserialize(
"StackInstance",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackResourceDriftsInput {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub stack_name: String,
pub stack_resource_drift_status_filters: Option<Vec<String>>,
}
struct DescribeStackResourceDriftsInputSerializer;
impl DescribeStackResourceDriftsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackResourceDriftsInput) {
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);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
if let Some(ref field_value) = obj.stack_resource_drift_status_filters {
StackResourceDriftStatusFiltersSerializer::serialize(
params,
&format!("{}{}", prefix, "StackResourceDriftStatusFilters"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackResourceDriftsOutput {
pub next_token: Option<String>,
pub stack_resource_drifts: Vec<StackResourceDrift>,
}
#[allow(dead_code)]
struct DescribeStackResourceDriftsOutputDeserializer;
impl DescribeStackResourceDriftsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackResourceDriftsOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackResourceDriftsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"StackResourceDrifts" => {
obj.stack_resource_drifts.extend(
StackResourceDriftsDeserializer::deserialize(
"StackResourceDrifts",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackResourceInput {
pub logical_resource_id: String,
pub stack_name: String,
}
struct DescribeStackResourceInputSerializer;
impl DescribeStackResourceInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackResourceInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "LogicalResourceId"),
&obj.logical_resource_id,
);
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackResourceOutput {
pub stack_resource_detail: Option<StackResourceDetail>,
}
#[allow(dead_code)]
struct DescribeStackResourceOutputDeserializer;
impl DescribeStackResourceOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackResourceOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackResourceOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StackResourceDetail" => {
obj.stack_resource_detail =
Some(StackResourceDetailDeserializer::deserialize(
"StackResourceDetail",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackResourcesInput {
pub logical_resource_id: Option<String>,
pub physical_resource_id: Option<String>,
pub stack_name: Option<String>,
}
struct DescribeStackResourcesInputSerializer;
impl DescribeStackResourcesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackResourcesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.logical_resource_id {
params.put(&format!("{}{}", prefix, "LogicalResourceId"), &field_value);
}
if let Some(ref field_value) = obj.physical_resource_id {
params.put(&format!("{}{}", prefix, "PhysicalResourceId"), &field_value);
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackResourcesOutput {
pub stack_resources: Option<Vec<StackResource>>,
}
#[allow(dead_code)]
struct DescribeStackResourcesOutputDeserializer;
impl DescribeStackResourcesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackResourcesOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackResourcesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StackResources" => {
obj.stack_resources.get_or_insert(vec![]).extend(
StackResourcesDeserializer::deserialize("StackResources", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackSetInput {
pub stack_set_name: String,
}
struct DescribeStackSetInputSerializer;
impl DescribeStackSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStackSetOperationInput {
pub operation_id: String,
pub stack_set_name: String,
}
struct DescribeStackSetOperationInputSerializer;
impl DescribeStackSetOperationInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStackSetOperationInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "OperationId"), &obj.operation_id);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackSetOperationOutput {
pub stack_set_operation: Option<StackSetOperation>,
}
#[allow(dead_code)]
struct DescribeStackSetOperationOutputDeserializer;
impl DescribeStackSetOperationOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackSetOperationOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackSetOperationOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StackSetOperation" => {
obj.stack_set_operation = Some(StackSetOperationDeserializer::deserialize(
"StackSetOperation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStackSetOutput {
pub stack_set: Option<StackSet>,
}
#[allow(dead_code)]
struct DescribeStackSetOutputDeserializer;
impl DescribeStackSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStackSetOutput, XmlParseError> {
deserialize_elements::<_, DescribeStackSetOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StackSet" => {
obj.stack_set = Some(StackSetDeserializer::deserialize("StackSet", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStacksInput {
pub next_token: Option<String>,
pub stack_name: Option<String>,
}
struct DescribeStacksInputSerializer;
impl DescribeStacksInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeStacksInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeStacksOutput {
pub next_token: Option<String>,
pub stacks: Option<Vec<Stack>>,
}
#[allow(dead_code)]
struct DescribeStacksOutputDeserializer;
impl DescribeStacksOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeStacksOutput, XmlParseError> {
deserialize_elements::<_, DescribeStacksOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Stacks" => {
obj.stacks
.get_or_insert(vec![])
.extend(StacksDeserializer::deserialize("Stacks", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTypeInput {
pub arn: Option<String>,
pub type_: Option<String>,
pub type_name: Option<String>,
pub version_id: Option<String>,
}
struct DescribeTypeInputSerializer;
impl DescribeTypeInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTypeInput) {
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.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.type_name {
params.put(&format!("{}{}", prefix, "TypeName"), &field_value);
}
if let Some(ref field_value) = obj.version_id {
params.put(&format!("{}{}", prefix, "VersionId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeTypeOutput {
pub arn: Option<String>,
pub default_version_id: Option<String>,
pub deprecated_status: Option<String>,
pub description: Option<String>,
pub documentation_url: Option<String>,
pub execution_role_arn: Option<String>,
pub is_default_version: Option<bool>,
pub last_updated: Option<String>,
pub logging_config: Option<LoggingConfig>,
pub provisioning_type: Option<String>,
pub schema: Option<String>,
pub source_url: Option<String>,
pub time_created: Option<String>,
pub type_: Option<String>,
pub type_name: Option<String>,
pub visibility: Option<String>,
}
#[allow(dead_code)]
struct DescribeTypeOutputDeserializer;
impl DescribeTypeOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTypeOutput, XmlParseError> {
deserialize_elements::<_, DescribeTypeOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Arn" => {
obj.arn = Some(TypeArnDeserializer::deserialize("Arn", stack)?);
}
"DefaultVersionId" => {
obj.default_version_id = Some(TypeVersionIdDeserializer::deserialize(
"DefaultVersionId",
stack,
)?);
}
"DeprecatedStatus" => {
obj.deprecated_status = Some(DeprecatedStatusDeserializer::deserialize(
"DeprecatedStatus",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"DocumentationUrl" => {
obj.documentation_url = Some(OptionalSecureUrlDeserializer::deserialize(
"DocumentationUrl",
stack,
)?);
}
"ExecutionRoleArn" => {
obj.execution_role_arn =
Some(RoleArnDeserializer::deserialize("ExecutionRoleArn", stack)?);
}
"IsDefaultVersion" => {
obj.is_default_version = Some(IsDefaultVersionDeserializer::deserialize(
"IsDefaultVersion",
stack,
)?);
}
"LastUpdated" => {
obj.last_updated =
Some(TimestampDeserializer::deserialize("LastUpdated", stack)?);
}
"LoggingConfig" => {
obj.logging_config = Some(LoggingConfigDeserializer::deserialize(
"LoggingConfig",
stack,
)?);
}
"ProvisioningType" => {
obj.provisioning_type = Some(ProvisioningTypeDeserializer::deserialize(
"ProvisioningType",
stack,
)?);
}
"Schema" => {
obj.schema = Some(TypeSchemaDeserializer::deserialize("Schema", stack)?);
}
"SourceUrl" => {
obj.source_url = Some(OptionalSecureUrlDeserializer::deserialize(
"SourceUrl",
stack,
)?);
}
"TimeCreated" => {
obj.time_created =
Some(TimestampDeserializer::deserialize("TimeCreated", stack)?);
}
"Type" => {
obj.type_ = Some(RegistryTypeDeserializer::deserialize("Type", stack)?);
}
"TypeName" => {
obj.type_name = Some(TypeNameDeserializer::deserialize("TypeName", stack)?);
}
"Visibility" => {
obj.visibility =
Some(VisibilityDeserializer::deserialize("Visibility", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTypeRegistrationInput {
pub registration_token: String,
}
struct DescribeTypeRegistrationInputSerializer;
impl DescribeTypeRegistrationInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTypeRegistrationInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "RegistrationToken"),
&obj.registration_token,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeTypeRegistrationOutput {
pub description: Option<String>,
pub progress_status: Option<String>,
pub type_arn: Option<String>,
pub type_version_arn: Option<String>,
}
#[allow(dead_code)]
struct DescribeTypeRegistrationOutputDeserializer;
impl DescribeTypeRegistrationOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTypeRegistrationOutput, XmlParseError> {
deserialize_elements::<_, DescribeTypeRegistrationOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"ProgressStatus" => {
obj.progress_status = Some(RegistrationStatusDeserializer::deserialize(
"ProgressStatus",
stack,
)?);
}
"TypeArn" => {
obj.type_arn = Some(TypeArnDeserializer::deserialize("TypeArn", stack)?);
}
"TypeVersionArn" => {
obj.type_version_arn =
Some(TypeArnDeserializer::deserialize("TypeVersionArn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DescriptionDeserializer;
impl DescriptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectStackDriftInput {
pub logical_resource_ids: Option<Vec<String>>,
pub stack_name: String,
}
struct DetectStackDriftInputSerializer;
impl DetectStackDriftInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetectStackDriftInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.logical_resource_ids {
LogicalResourceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "LogicalResourceIds"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DetectStackDriftOutput {
pub stack_drift_detection_id: String,
}
#[allow(dead_code)]
struct DetectStackDriftOutputDeserializer;
impl DetectStackDriftOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetectStackDriftOutput, XmlParseError> {
deserialize_elements::<_, DetectStackDriftOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StackDriftDetectionId" => {
obj.stack_drift_detection_id = StackDriftDetectionIdDeserializer::deserialize(
"StackDriftDetectionId",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectStackResourceDriftInput {
pub logical_resource_id: String,
pub stack_name: String,
}
struct DetectStackResourceDriftInputSerializer;
impl DetectStackResourceDriftInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetectStackResourceDriftInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "LogicalResourceId"),
&obj.logical_resource_id,
);
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DetectStackResourceDriftOutput {
pub stack_resource_drift: StackResourceDrift,
}
#[allow(dead_code)]
struct DetectStackResourceDriftOutputDeserializer;
impl DetectStackResourceDriftOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetectStackResourceDriftOutput, XmlParseError> {
deserialize_elements::<_, DetectStackResourceDriftOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StackResourceDrift" => {
obj.stack_resource_drift = StackResourceDriftDeserializer::deserialize(
"StackResourceDrift",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetectStackSetDriftInput {
pub operation_id: Option<String>,
pub operation_preferences: Option<StackSetOperationPreferences>,
pub stack_set_name: String,
}
struct DetectStackSetDriftInputSerializer;
impl DetectStackSetDriftInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetectStackSetDriftInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.operation_id {
params.put(&format!("{}{}", prefix, "OperationId"), &field_value);
}
if let Some(ref field_value) = obj.operation_preferences {
StackSetOperationPreferencesSerializer::serialize(
params,
&format!("{}{}", prefix, "OperationPreferences"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DetectStackSetDriftOutput {
pub operation_id: Option<String>,
}
#[allow(dead_code)]
struct DetectStackSetDriftOutputDeserializer;
impl DetectStackSetDriftOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetectStackSetDriftOutput, XmlParseError> {
deserialize_elements::<_, DetectStackSetDriftOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DifferenceTypeDeserializer;
impl DifferenceTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct DisableRollbackDeserializer;
impl DisableRollbackDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct DriftedStackInstancesCountDeserializer;
impl DriftedStackInstancesCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct EnableTerminationProtectionDeserializer;
impl EnableTerminationProtectionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EstimateTemplateCostInput {
pub parameters: Option<Vec<Parameter>>,
pub template_body: Option<String>,
pub template_url: Option<String>,
}
struct EstimateTemplateCostInputSerializer;
impl EstimateTemplateCostInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EstimateTemplateCostInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.parameters {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameters"),
field_value,
);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EstimateTemplateCostOutput {
pub url: Option<String>,
}
#[allow(dead_code)]
struct EstimateTemplateCostOutputDeserializer;
impl EstimateTemplateCostOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EstimateTemplateCostOutput, XmlParseError> {
deserialize_elements::<_, EstimateTemplateCostOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Url" => {
obj.url = Some(UrlDeserializer::deserialize("Url", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct EvaluationTypeDeserializer;
impl EvaluationTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct EventIdDeserializer;
impl EventIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExecuteChangeSetInput {
pub change_set_name: String,
pub client_request_token: Option<String>,
pub stack_name: Option<String>,
}
struct ExecuteChangeSetInputSerializer;
impl ExecuteChangeSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ExecuteChangeSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ChangeSetName"),
&obj.change_set_name,
);
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ExecuteChangeSetOutput {}
#[allow(dead_code)]
struct ExecuteChangeSetOutputDeserializer;
impl ExecuteChangeSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExecuteChangeSetOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = ExecuteChangeSetOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct ExecutionRoleNameDeserializer;
impl ExecutionRoleNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ExecutionStatusDeserializer;
impl ExecutionStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Export {
pub exporting_stack_id: Option<String>,
pub name: Option<String>,
pub value: Option<String>,
}
#[allow(dead_code)]
struct ExportDeserializer;
impl ExportDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Export, XmlParseError> {
deserialize_elements::<_, Export, _>(tag_name, stack, |name, stack, obj| {
match name {
"ExportingStackId" => {
obj.exporting_stack_id =
Some(StackIdDeserializer::deserialize("ExportingStackId", stack)?);
}
"Name" => {
obj.name = Some(ExportNameDeserializer::deserialize("Name", stack)?);
}
"Value" => {
obj.value = Some(ExportValueDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ExportNameDeserializer;
impl ExportNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ExportValueDeserializer;
impl ExportValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ExportsDeserializer;
impl ExportsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Export>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ExportDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct FailedStackInstancesCountDeserializer;
impl FailedStackInstancesCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct FailureToleranceCountDeserializer;
impl FailureToleranceCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct FailureTolerancePercentageDeserializer;
impl FailureTolerancePercentageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStackPolicyInput {
pub stack_name: String,
}
struct GetStackPolicyInputSerializer;
impl GetStackPolicyInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetStackPolicyInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetStackPolicyOutput {
pub stack_policy_body: Option<String>,
}
#[allow(dead_code)]
struct GetStackPolicyOutputDeserializer;
impl GetStackPolicyOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetStackPolicyOutput, XmlParseError> {
deserialize_elements::<_, GetStackPolicyOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StackPolicyBody" => {
obj.stack_policy_body = Some(StackPolicyBodyDeserializer::deserialize(
"StackPolicyBody",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTemplateInput {
pub change_set_name: Option<String>,
pub stack_name: Option<String>,
pub template_stage: Option<String>,
}
struct GetTemplateInputSerializer;
impl GetTemplateInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetTemplateInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.change_set_name {
params.put(&format!("{}{}", prefix, "ChangeSetName"), &field_value);
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
if let Some(ref field_value) = obj.template_stage {
params.put(&format!("{}{}", prefix, "TemplateStage"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetTemplateOutput {
pub stages_available: Option<Vec<String>>,
pub template_body: Option<String>,
}
#[allow(dead_code)]
struct GetTemplateOutputDeserializer;
impl GetTemplateOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTemplateOutput, XmlParseError> {
deserialize_elements::<_, GetTemplateOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StagesAvailable" => {
obj.stages_available.get_or_insert(vec![]).extend(
StageListDeserializer::deserialize("StagesAvailable", stack)?,
);
}
"TemplateBody" => {
obj.template_body = Some(TemplateBodyDeserializer::deserialize(
"TemplateBody",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTemplateSummaryInput {
pub stack_name: Option<String>,
pub stack_set_name: Option<String>,
pub template_body: Option<String>,
pub template_url: Option<String>,
}
struct GetTemplateSummaryInputSerializer;
impl GetTemplateSummaryInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetTemplateSummaryInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.stack_name {
params.put(&format!("{}{}", prefix, "StackName"), &field_value);
}
if let Some(ref field_value) = obj.stack_set_name {
params.put(&format!("{}{}", prefix, "StackSetName"), &field_value);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetTemplateSummaryOutput {
pub capabilities: Option<Vec<String>>,
pub capabilities_reason: Option<String>,
pub declared_transforms: Option<Vec<String>>,
pub description: Option<String>,
pub metadata: Option<String>,
pub parameters: Option<Vec<ParameterDeclaration>>,
pub resource_identifier_summaries: Option<Vec<ResourceIdentifierSummary>>,
pub resource_types: Option<Vec<String>>,
pub version: Option<String>,
}
#[allow(dead_code)]
struct GetTemplateSummaryOutputDeserializer;
impl GetTemplateSummaryOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTemplateSummaryOutput, XmlParseError> {
deserialize_elements::<_, GetTemplateSummaryOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Capabilities" => {
obj.capabilities.get_or_insert(vec![]).extend(
CapabilitiesDeserializer::deserialize("Capabilities", stack)?,
);
}
"CapabilitiesReason" => {
obj.capabilities_reason =
Some(CapabilitiesReasonDeserializer::deserialize(
"CapabilitiesReason",
stack,
)?);
}
"DeclaredTransforms" => {
obj.declared_transforms.get_or_insert(vec![]).extend(
TransformsListDeserializer::deserialize("DeclaredTransforms", stack)?,
);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"Metadata" => {
obj.metadata = Some(MetadataDeserializer::deserialize("Metadata", stack)?);
}
"Parameters" => {
obj.parameters.get_or_insert(vec![]).extend(
ParameterDeclarationsDeserializer::deserialize("Parameters", stack)?,
);
}
"ResourceIdentifierSummaries" => {
obj.resource_identifier_summaries
.get_or_insert(vec![])
.extend(ResourceIdentifierSummariesDeserializer::deserialize(
"ResourceIdentifierSummaries",
stack,
)?);
}
"ResourceTypes" => {
obj.resource_types.get_or_insert(vec![]).extend(
ResourceTypesDeserializer::deserialize("ResourceTypes", stack)?,
);
}
"Version" => {
obj.version = Some(VersionDeserializer::deserialize("Version", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ImportsDeserializer;
impl ImportsDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(StackNameDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InProgressStackInstancesCountDeserializer;
impl InProgressStackInstancesCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct InSyncStackInstancesCountDeserializer;
impl InSyncStackInstancesCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct IsDefaultVersionDeserializer;
impl IsDefaultVersionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct KeyDeserializer;
impl KeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct LastUpdatedTimeDeserializer;
impl LastUpdatedTimeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct LimitNameDeserializer;
impl LimitNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct LimitValueDeserializer;
impl LimitValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListChangeSetsInput {
pub next_token: Option<String>,
pub stack_name: String,
}
struct ListChangeSetsInputSerializer;
impl ListChangeSetsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListChangeSetsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListChangeSetsOutput {
pub next_token: Option<String>,
pub summaries: Option<Vec<ChangeSetSummary>>,
}
#[allow(dead_code)]
struct ListChangeSetsOutputDeserializer;
impl ListChangeSetsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListChangeSetsOutput, XmlParseError> {
deserialize_elements::<_, ListChangeSetsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Summaries" => {
obj.summaries.get_or_insert(vec![]).extend(
ChangeSetSummariesDeserializer::deserialize("Summaries", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListExportsInput {
pub next_token: Option<String>,
}
struct ListExportsInputSerializer;
impl ListExportsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListExportsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListExportsOutput {
pub exports: Option<Vec<Export>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct ListExportsOutputDeserializer;
impl ListExportsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListExportsOutput, XmlParseError> {
deserialize_elements::<_, ListExportsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Exports" => {
obj.exports
.get_or_insert(vec![])
.extend(ExportsDeserializer::deserialize("Exports", stack)?);
}
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImportsInput {
pub export_name: String,
pub next_token: Option<String>,
}
struct ListImportsInputSerializer;
impl ListImportsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListImportsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ExportName"), &obj.export_name);
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListImportsOutput {
pub imports: Option<Vec<String>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct ListImportsOutputDeserializer;
impl ListImportsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListImportsOutput, XmlParseError> {
deserialize_elements::<_, ListImportsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Imports" => {
obj.imports
.get_or_insert(vec![])
.extend(ImportsDeserializer::deserialize("Imports", stack)?);
}
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStackInstancesInput {
pub filters: Option<Vec<StackInstanceFilter>>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub stack_instance_account: Option<String>,
pub stack_instance_region: Option<String>,
pub stack_set_name: String,
}
struct ListStackInstancesInputSerializer;
impl ListStackInstancesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListStackInstancesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
StackInstanceFiltersSerializer::serialize(
params,
&format!("{}{}", prefix, "Filters"),
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.stack_instance_account {
params.put(
&format!("{}{}", prefix, "StackInstanceAccount"),
&field_value,
);
}
if let Some(ref field_value) = obj.stack_instance_region {
params.put(
&format!("{}{}", prefix, "StackInstanceRegion"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStackInstancesOutput {
pub next_token: Option<String>,
pub summaries: Option<Vec<StackInstanceSummary>>,
}
#[allow(dead_code)]
struct ListStackInstancesOutputDeserializer;
impl ListStackInstancesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStackInstancesOutput, XmlParseError> {
deserialize_elements::<_, ListStackInstancesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Summaries" => {
obj.summaries.get_or_insert(vec![]).extend(
StackInstanceSummariesDeserializer::deserialize("Summaries", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStackResourcesInput {
pub next_token: Option<String>,
pub stack_name: String,
}
struct ListStackResourcesInputSerializer;
impl ListStackResourcesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListStackResourcesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStackResourcesOutput {
pub next_token: Option<String>,
pub stack_resource_summaries: Option<Vec<StackResourceSummary>>,
}
#[allow(dead_code)]
struct ListStackResourcesOutputDeserializer;
impl ListStackResourcesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStackResourcesOutput, XmlParseError> {
deserialize_elements::<_, ListStackResourcesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"StackResourceSummaries" => {
obj.stack_resource_summaries.get_or_insert(vec![]).extend(
StackResourceSummariesDeserializer::deserialize(
"StackResourceSummaries",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStackSetOperationResultsInput {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub operation_id: String,
pub stack_set_name: String,
}
struct ListStackSetOperationResultsInputSerializer;
impl ListStackSetOperationResultsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListStackSetOperationResultsInput) {
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);
}
params.put(&format!("{}{}", prefix, "OperationId"), &obj.operation_id);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStackSetOperationResultsOutput {
pub next_token: Option<String>,
pub summaries: Option<Vec<StackSetOperationResultSummary>>,
}
#[allow(dead_code)]
struct ListStackSetOperationResultsOutputDeserializer;
impl ListStackSetOperationResultsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStackSetOperationResultsOutput, XmlParseError> {
deserialize_elements::<_, ListStackSetOperationResultsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Summaries" => {
obj.summaries.get_or_insert(vec![]).extend(
StackSetOperationResultSummariesDeserializer::deserialize(
"Summaries",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStackSetOperationsInput {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub stack_set_name: String,
}
struct ListStackSetOperationsInputSerializer;
impl ListStackSetOperationsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListStackSetOperationsInput) {
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);
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStackSetOperationsOutput {
pub next_token: Option<String>,
pub summaries: Option<Vec<StackSetOperationSummary>>,
}
#[allow(dead_code)]
struct ListStackSetOperationsOutputDeserializer;
impl ListStackSetOperationsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStackSetOperationsOutput, XmlParseError> {
deserialize_elements::<_, ListStackSetOperationsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Summaries" => {
obj.summaries.get_or_insert(vec![]).extend(
StackSetOperationSummariesDeserializer::deserialize(
"Summaries",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStackSetsInput {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub status: Option<String>,
}
struct ListStackSetsInputSerializer;
impl ListStackSetsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListStackSetsInput) {
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.status {
params.put(&format!("{}{}", prefix, "Status"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStackSetsOutput {
pub next_token: Option<String>,
pub summaries: Option<Vec<StackSetSummary>>,
}
#[allow(dead_code)]
struct ListStackSetsOutputDeserializer;
impl ListStackSetsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStackSetsOutput, XmlParseError> {
deserialize_elements::<_, ListStackSetsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Summaries" => {
obj.summaries.get_or_insert(vec![]).extend(
StackSetSummariesDeserializer::deserialize("Summaries", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStacksInput {
pub next_token: Option<String>,
pub stack_status_filter: Option<Vec<String>>,
}
struct ListStacksInputSerializer;
impl ListStacksInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListStacksInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.stack_status_filter {
StackStatusFilterSerializer::serialize(
params,
&format!("{}{}", prefix, "StackStatusFilter"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStacksOutput {
pub next_token: Option<String>,
pub stack_summaries: Option<Vec<StackSummary>>,
}
#[allow(dead_code)]
struct ListStacksOutputDeserializer;
impl ListStacksOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStacksOutput, XmlParseError> {
deserialize_elements::<_, ListStacksOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"StackSummaries" => {
obj.stack_summaries.get_or_insert(vec![]).extend(
StackSummariesDeserializer::deserialize("StackSummaries", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTypeRegistrationsInput {
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub registration_status_filter: Option<String>,
pub type_: Option<String>,
pub type_arn: Option<String>,
pub type_name: Option<String>,
}
struct ListTypeRegistrationsInputSerializer;
impl ListTypeRegistrationsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTypeRegistrationsInput) {
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.registration_status_filter {
params.put(
&format!("{}{}", prefix, "RegistrationStatusFilter"),
&field_value,
);
}
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.type_arn {
params.put(&format!("{}{}", prefix, "TypeArn"), &field_value);
}
if let Some(ref field_value) = obj.type_name {
params.put(&format!("{}{}", prefix, "TypeName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTypeRegistrationsOutput {
pub next_token: Option<String>,
pub registration_token_list: Option<Vec<String>>,
}
#[allow(dead_code)]
struct ListTypeRegistrationsOutputDeserializer;
impl ListTypeRegistrationsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTypeRegistrationsOutput, XmlParseError> {
deserialize_elements::<_, ListTypeRegistrationsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"RegistrationTokenList" => {
obj.registration_token_list.get_or_insert(vec![]).extend(
RegistrationTokenListDeserializer::deserialize(
"RegistrationTokenList",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTypeVersionsInput {
pub arn: Option<String>,
pub deprecated_status: Option<String>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub type_: Option<String>,
pub type_name: Option<String>,
}
struct ListTypeVersionsInputSerializer;
impl ListTypeVersionsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTypeVersionsInput) {
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.deprecated_status {
params.put(&format!("{}{}", prefix, "DeprecatedStatus"), &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.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.type_name {
params.put(&format!("{}{}", prefix, "TypeName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTypeVersionsOutput {
pub next_token: Option<String>,
pub type_version_summaries: Option<Vec<TypeVersionSummary>>,
}
#[allow(dead_code)]
struct ListTypeVersionsOutputDeserializer;
impl ListTypeVersionsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTypeVersionsOutput, XmlParseError> {
deserialize_elements::<_, ListTypeVersionsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"TypeVersionSummaries" => {
obj.type_version_summaries.get_or_insert(vec![]).extend(
TypeVersionSummariesDeserializer::deserialize(
"TypeVersionSummaries",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTypesInput {
pub deprecated_status: Option<String>,
pub max_results: Option<i64>,
pub next_token: Option<String>,
pub provisioning_type: Option<String>,
pub visibility: Option<String>,
}
struct ListTypesInputSerializer;
impl ListTypesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTypesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deprecated_status {
params.put(&format!("{}{}", prefix, "DeprecatedStatus"), &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.provisioning_type {
params.put(&format!("{}{}", prefix, "ProvisioningType"), &field_value);
}
if let Some(ref field_value) = obj.visibility {
params.put(&format!("{}{}", prefix, "Visibility"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTypesOutput {
pub next_token: Option<String>,
pub type_summaries: Option<Vec<TypeSummary>>,
}
#[allow(dead_code)]
struct ListTypesOutputDeserializer;
impl ListTypesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTypesOutput, XmlParseError> {
deserialize_elements::<_, ListTypesOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"TypeSummaries" => {
obj.type_summaries.get_or_insert(vec![]).extend(
TypeSummariesDeserializer::deserialize("TypeSummaries", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct LogGroupNameDeserializer;
impl LogGroupNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LoggingConfig {
pub log_group_name: String,
pub log_role_arn: String,
}
#[allow(dead_code)]
struct LoggingConfigDeserializer;
impl LoggingConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoggingConfig, XmlParseError> {
deserialize_elements::<_, LoggingConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"LogGroupName" => {
obj.log_group_name =
LogGroupNameDeserializer::deserialize("LogGroupName", stack)?;
}
"LogRoleArn" => {
obj.log_role_arn = RoleArnDeserializer::deserialize("LogRoleArn", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LoggingConfigSerializer;
impl LoggingConfigSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LoggingConfig) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "LogGroupName"),
&obj.log_group_name,
);
params.put(&format!("{}{}", prefix, "LogRoleArn"), &obj.log_role_arn);
}
}
#[allow(dead_code)]
struct LogicalResourceIdDeserializer;
impl LogicalResourceIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct LogicalResourceIdsDeserializer;
impl LogicalResourceIdsDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(LogicalResourceIdDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct LogicalResourceIdsSerializer;
impl LogicalResourceIdsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct MaxConcurrentCountDeserializer;
impl MaxConcurrentCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct MaxConcurrentPercentageDeserializer;
impl MaxConcurrentPercentageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct MetadataDeserializer;
impl MetadataDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct MonitoringTimeInMinutesDeserializer;
impl MonitoringTimeInMinutesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct NextTokenDeserializer;
impl NextTokenDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct NoEchoDeserializer;
impl NoEchoDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct NotificationARNDeserializer;
impl NotificationARNDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct NotificationARNsDeserializer;
impl NotificationARNsDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(NotificationARNDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NotificationARNsSerializer;
impl NotificationARNsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct OptionalSecureUrlDeserializer;
impl OptionalSecureUrlDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct OrganizationalUnitIdDeserializer;
impl OrganizationalUnitIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct OrganizationalUnitIdListDeserializer;
impl OrganizationalUnitIdListDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(OrganizationalUnitIdDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct OrganizationalUnitIdListSerializer;
impl OrganizationalUnitIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Output {
pub description: Option<String>,
pub export_name: Option<String>,
pub output_key: Option<String>,
pub output_value: Option<String>,
}
#[allow(dead_code)]
struct OutputDeserializer;
impl OutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Output, XmlParseError> {
deserialize_elements::<_, Output, _>(tag_name, stack, |name, stack, obj| {
match name {
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"ExportName" => {
obj.export_name =
Some(ExportNameDeserializer::deserialize("ExportName", stack)?);
}
"OutputKey" => {
obj.output_key = Some(OutputKeyDeserializer::deserialize("OutputKey", stack)?);
}
"OutputValue" => {
obj.output_value =
Some(OutputValueDeserializer::deserialize("OutputValue", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct OutputKeyDeserializer;
impl OutputKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct OutputValueDeserializer;
impl OutputValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct OutputsDeserializer;
impl OutputsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Output>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(OutputDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Parameter {
pub parameter_key: Option<String>,
pub parameter_value: Option<String>,
pub resolved_value: Option<String>,
pub use_previous_value: Option<bool>,
}
#[allow(dead_code)]
struct ParameterDeserializer;
impl ParameterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Parameter, XmlParseError> {
deserialize_elements::<_, Parameter, _>(tag_name, stack, |name, stack, obj| {
match name {
"ParameterKey" => {
obj.parameter_key = Some(ParameterKeyDeserializer::deserialize(
"ParameterKey",
stack,
)?);
}
"ParameterValue" => {
obj.parameter_value = Some(ParameterValueDeserializer::deserialize(
"ParameterValue",
stack,
)?);
}
"ResolvedValue" => {
obj.resolved_value = Some(ParameterValueDeserializer::deserialize(
"ResolvedValue",
stack,
)?);
}
"UsePreviousValue" => {
obj.use_previous_value = Some(UsePreviousValueDeserializer::deserialize(
"UsePreviousValue",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ParameterSerializer;
impl ParameterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Parameter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.parameter_key {
params.put(&format!("{}{}", prefix, "ParameterKey"), &field_value);
}
if let Some(ref field_value) = obj.parameter_value {
params.put(&format!("{}{}", prefix, "ParameterValue"), &field_value);
}
if let Some(ref field_value) = obj.resolved_value {
params.put(&format!("{}{}", prefix, "ResolvedValue"), &field_value);
}
if let Some(ref field_value) = obj.use_previous_value {
params.put(&format!("{}{}", prefix, "UsePreviousValue"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ParameterConstraints {
pub allowed_values: Option<Vec<String>>,
}
#[allow(dead_code)]
struct ParameterConstraintsDeserializer;
impl ParameterConstraintsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ParameterConstraints, XmlParseError> {
deserialize_elements::<_, ParameterConstraints, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowedValues" => {
obj.allowed_values.get_or_insert(vec![]).extend(
AllowedValuesDeserializer::deserialize("AllowedValues", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ParameterDeclaration {
pub default_value: Option<String>,
pub description: Option<String>,
pub no_echo: Option<bool>,
pub parameter_constraints: Option<ParameterConstraints>,
pub parameter_key: Option<String>,
pub parameter_type: Option<String>,
}
#[allow(dead_code)]
struct ParameterDeclarationDeserializer;
impl ParameterDeclarationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ParameterDeclaration, XmlParseError> {
deserialize_elements::<_, ParameterDeclaration, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value = Some(ParameterValueDeserializer::deserialize(
"DefaultValue",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"NoEcho" => {
obj.no_echo = Some(NoEchoDeserializer::deserialize("NoEcho", stack)?);
}
"ParameterConstraints" => {
obj.parameter_constraints =
Some(ParameterConstraintsDeserializer::deserialize(
"ParameterConstraints",
stack,
)?);
}
"ParameterKey" => {
obj.parameter_key = Some(ParameterKeyDeserializer::deserialize(
"ParameterKey",
stack,
)?);
}
"ParameterType" => {
obj.parameter_type = Some(ParameterTypeDeserializer::deserialize(
"ParameterType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ParameterDeclarationsDeserializer;
impl ParameterDeclarationsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ParameterDeclaration>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ParameterDeclarationDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ParameterKeyDeserializer;
impl ParameterKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ParameterTypeDeserializer;
impl ParameterTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ParameterValueDeserializer;
impl ParameterValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ParametersDeserializer;
impl ParametersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Parameter>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ParameterDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ParametersSerializer;
impl ParametersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Parameter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ParameterSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct PermissionModelsDeserializer;
impl PermissionModelsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct PhysicalResourceIdDeserializer;
impl PhysicalResourceIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct PhysicalResourceIdContextDeserializer;
impl PhysicalResourceIdContextDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PhysicalResourceIdContextKeyValuePair>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(
PhysicalResourceIdContextKeyValuePairDeserializer::deserialize(
"member", stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PhysicalResourceIdContextKeyValuePair {
pub key: String,
pub value: String,
}
#[allow(dead_code)]
struct PhysicalResourceIdContextKeyValuePairDeserializer;
impl PhysicalResourceIdContextKeyValuePairDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PhysicalResourceIdContextKeyValuePair, XmlParseError> {
deserialize_elements::<_, PhysicalResourceIdContextKeyValuePair, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Key" => {
obj.key = KeyDeserializer::deserialize("Key", stack)?;
}
"Value" => {
obj.value = ValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct PropertiesDeserializer;
impl PropertiesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PropertyDifference {
pub actual_value: String,
pub difference_type: String,
pub expected_value: String,
pub property_path: String,
}
#[allow(dead_code)]
struct PropertyDifferenceDeserializer;
impl PropertyDifferenceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PropertyDifference, XmlParseError> {
deserialize_elements::<_, PropertyDifference, _>(tag_name, stack, |name, stack, obj| {
match name {
"ActualValue" => {
obj.actual_value =
PropertyValueDeserializer::deserialize("ActualValue", stack)?;
}
"DifferenceType" => {
obj.difference_type =
DifferenceTypeDeserializer::deserialize("DifferenceType", stack)?;
}
"ExpectedValue" => {
obj.expected_value =
PropertyValueDeserializer::deserialize("ExpectedValue", stack)?;
}
"PropertyPath" => {
obj.property_path =
PropertyPathDeserializer::deserialize("PropertyPath", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PropertyDifferencesDeserializer;
impl PropertyDifferencesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PropertyDifference>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(PropertyDifferenceDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PropertyNameDeserializer;
impl PropertyNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct PropertyPathDeserializer;
impl PropertyPathDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct PropertyValueDeserializer;
impl PropertyValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ProvisioningTypeDeserializer;
impl ProvisioningTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ReasonDeserializer;
impl ReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RecordHandlerProgressInput {
pub bearer_token: String,
pub client_request_token: Option<String>,
pub current_operation_status: Option<String>,
pub error_code: Option<String>,
pub operation_status: String,
pub resource_model: Option<String>,
pub status_message: Option<String>,
}
struct RecordHandlerProgressInputSerializer;
impl RecordHandlerProgressInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RecordHandlerProgressInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "BearerToken"), &obj.bearer_token);
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.current_operation_status {
params.put(
&format!("{}{}", prefix, "CurrentOperationStatus"),
&field_value,
);
}
if let Some(ref field_value) = obj.error_code {
params.put(&format!("{}{}", prefix, "ErrorCode"), &field_value);
}
params.put(
&format!("{}{}", prefix, "OperationStatus"),
&obj.operation_status,
);
if let Some(ref field_value) = obj.resource_model {
params.put(&format!("{}{}", prefix, "ResourceModel"), &field_value);
}
if let Some(ref field_value) = obj.status_message {
params.put(&format!("{}{}", prefix, "StatusMessage"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RecordHandlerProgressOutput {}
#[allow(dead_code)]
struct RecordHandlerProgressOutputDeserializer;
impl RecordHandlerProgressOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RecordHandlerProgressOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = RecordHandlerProgressOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct RegionDeserializer;
impl RegionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct RegionListDeserializer;
impl RegionListDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(RegionDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RegionListSerializer;
impl RegionListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterTypeInput {
pub client_request_token: Option<String>,
pub execution_role_arn: Option<String>,
pub logging_config: Option<LoggingConfig>,
pub schema_handler_package: String,
pub type_: Option<String>,
pub type_name: String,
}
struct RegisterTypeInputSerializer;
impl RegisterTypeInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RegisterTypeInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.execution_role_arn {
params.put(&format!("{}{}", prefix, "ExecutionRoleArn"), &field_value);
}
if let Some(ref field_value) = obj.logging_config {
LoggingConfigSerializer::serialize(
params,
&format!("{}{}", prefix, "LoggingConfig"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "SchemaHandlerPackage"),
&obj.schema_handler_package,
);
if let Some(ref field_value) = obj.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
params.put(&format!("{}{}", prefix, "TypeName"), &obj.type_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RegisterTypeOutput {
pub registration_token: Option<String>,
}
#[allow(dead_code)]
struct RegisterTypeOutputDeserializer;
impl RegisterTypeOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RegisterTypeOutput, XmlParseError> {
deserialize_elements::<_, RegisterTypeOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"RegistrationToken" => {
obj.registration_token = Some(RegistrationTokenDeserializer::deserialize(
"RegistrationToken",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct RegistrationStatusDeserializer;
impl RegistrationStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct RegistrationTokenDeserializer;
impl RegistrationTokenDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct RegistrationTokenListDeserializer;
impl RegistrationTokenListDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(RegistrationTokenDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct RegistryTypeDeserializer;
impl RegistryTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ReplacementDeserializer;
impl ReplacementDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct RequiresRecreationDeserializer;
impl RequiresRecreationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ResourceAttributeDeserializer;
impl ResourceAttributeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResourceChange {
pub action: Option<String>,
pub details: Option<Vec<ResourceChangeDetail>>,
pub logical_resource_id: Option<String>,
pub physical_resource_id: Option<String>,
pub replacement: Option<String>,
pub resource_type: Option<String>,
pub scope: Option<Vec<String>>,
}
#[allow(dead_code)]
struct ResourceChangeDeserializer;
impl ResourceChangeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceChange, XmlParseError> {
deserialize_elements::<_, ResourceChange, _>(tag_name, stack, |name, stack, obj| {
match name {
"Action" => {
obj.action = Some(ChangeActionDeserializer::deserialize("Action", stack)?);
}
"Details" => {
obj.details.get_or_insert(vec![]).extend(
ResourceChangeDetailsDeserializer::deserialize("Details", stack)?,
);
}
"LogicalResourceId" => {
obj.logical_resource_id = Some(LogicalResourceIdDeserializer::deserialize(
"LogicalResourceId",
stack,
)?);
}
"PhysicalResourceId" => {
obj.physical_resource_id = Some(PhysicalResourceIdDeserializer::deserialize(
"PhysicalResourceId",
stack,
)?);
}
"Replacement" => {
obj.replacement =
Some(ReplacementDeserializer::deserialize("Replacement", stack)?);
}
"ResourceType" => {
obj.resource_type = Some(ResourceTypeDeserializer::deserialize(
"ResourceType",
stack,
)?);
}
"Scope" => {
obj.scope
.get_or_insert(vec![])
.extend(ScopeDeserializer::deserialize("Scope", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResourceChangeDetail {
pub causing_entity: Option<String>,
pub change_source: Option<String>,
pub evaluation: Option<String>,
pub target: Option<ResourceTargetDefinition>,
}
#[allow(dead_code)]
struct ResourceChangeDetailDeserializer;
impl ResourceChangeDetailDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceChangeDetail, XmlParseError> {
deserialize_elements::<_, ResourceChangeDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"CausingEntity" => {
obj.causing_entity = Some(CausingEntityDeserializer::deserialize(
"CausingEntity",
stack,
)?);
}
"ChangeSource" => {
obj.change_source = Some(ChangeSourceDeserializer::deserialize(
"ChangeSource",
stack,
)?);
}
"Evaluation" => {
obj.evaluation = Some(EvaluationTypeDeserializer::deserialize(
"Evaluation",
stack,
)?);
}
"Target" => {
obj.target = Some(ResourceTargetDefinitionDeserializer::deserialize(
"Target", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ResourceChangeDetailsDeserializer;
impl ResourceChangeDetailsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ResourceChangeDetail>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ResourceChangeDetailDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ResourceIdentifierPropertiesSerializer;
impl ResourceIdentifierPropertiesSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &::std::collections::HashMap<String, String>,
) {
for (index, (key, value)) in obj.iter().enumerate() {
let prefix = format!("{}.{}", name, index + 1);
params.put(&format!("{}.{}", prefix, "key"), &key);
params.put(&format!("{}.{}", prefix, "Value"), &value);
}
}
}
#[allow(dead_code)]
struct ResourceIdentifierPropertyKeyDeserializer;
impl ResourceIdentifierPropertyKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ResourceIdentifierSummariesDeserializer;
impl ResourceIdentifierSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ResourceIdentifierSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ResourceIdentifierSummaryDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResourceIdentifierSummary {
pub logical_resource_ids: Option<Vec<String>>,
pub resource_identifiers: Option<Vec<String>>,
pub resource_type: Option<String>,
}
#[allow(dead_code)]
struct ResourceIdentifierSummaryDeserializer;
impl ResourceIdentifierSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceIdentifierSummary, XmlParseError> {
deserialize_elements::<_, ResourceIdentifierSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"LogicalResourceIds" => {
obj.logical_resource_ids.get_or_insert(vec![]).extend(
LogicalResourceIdsDeserializer::deserialize(
"LogicalResourceIds",
stack,
)?,
);
}
"ResourceIdentifiers" => {
obj.resource_identifiers.get_or_insert(vec![]).extend(
ResourceIdentifiersDeserializer::deserialize(
"ResourceIdentifiers",
stack,
)?,
);
}
"ResourceType" => {
obj.resource_type = Some(ResourceTypeDeserializer::deserialize(
"ResourceType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ResourceIdentifiersDeserializer;
impl ResourceIdentifiersDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(ResourceIdentifierPropertyKeyDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ResourcePropertiesDeserializer;
impl ResourcePropertiesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ResourceStatusDeserializer;
impl ResourceStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ResourceStatusReasonDeserializer;
impl ResourceStatusReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResourceTargetDefinition {
pub attribute: Option<String>,
pub name: Option<String>,
pub requires_recreation: Option<String>,
}
#[allow(dead_code)]
struct ResourceTargetDefinitionDeserializer;
impl ResourceTargetDefinitionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceTargetDefinition, XmlParseError> {
deserialize_elements::<_, ResourceTargetDefinition, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Attribute" => {
obj.attribute = Some(ResourceAttributeDeserializer::deserialize(
"Attribute",
stack,
)?);
}
"Name" => {
obj.name = Some(PropertyNameDeserializer::deserialize("Name", stack)?);
}
"RequiresRecreation" => {
obj.requires_recreation =
Some(RequiresRecreationDeserializer::deserialize(
"RequiresRecreation",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResourceToImport {
pub logical_resource_id: String,
pub resource_identifier: ::std::collections::HashMap<String, String>,
pub resource_type: String,
}
struct ResourceToImportSerializer;
impl ResourceToImportSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResourceToImport) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "LogicalResourceId"),
&obj.logical_resource_id,
);
ResourceIdentifierPropertiesSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceIdentifier"),
&obj.resource_identifier,
);
params.put(&format!("{}{}", prefix, "ResourceType"), &obj.resource_type);
}
}
#[allow(dead_code)]
struct ResourceTypeDeserializer;
impl ResourceTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ResourceTypesDeserializer;
impl ResourceTypesDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(ResourceTypeDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ResourceTypesSerializer;
impl ResourceTypesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct ResourcesToImportSerializer;
impl ResourcesToImportSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ResourceToImport>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ResourceToImportSerializer::serialize(params, &key, obj);
}
}
}
struct ResourcesToSkipSerializer;
impl ResourcesToSkipSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct RetainResourcesSerializer;
impl RetainResourcesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct RetainStacksNullableDeserializer;
impl RetainStacksNullableDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct RetainStacksOnAccountRemovalNullableDeserializer;
impl RetainStacksOnAccountRemovalNullableDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct RoleARNDeserializer;
impl RoleARNDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct RoleArnDeserializer;
impl RoleArnDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RollbackConfiguration {
pub monitoring_time_in_minutes: Option<i64>,
pub rollback_triggers: Option<Vec<RollbackTrigger>>,
}
#[allow(dead_code)]
struct RollbackConfigurationDeserializer;
impl RollbackConfigurationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RollbackConfiguration, XmlParseError> {
deserialize_elements::<_, RollbackConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"MonitoringTimeInMinutes" => {
obj.monitoring_time_in_minutes =
Some(MonitoringTimeInMinutesDeserializer::deserialize(
"MonitoringTimeInMinutes",
stack,
)?);
}
"RollbackTriggers" => {
obj.rollback_triggers.get_or_insert(vec![]).extend(
RollbackTriggersDeserializer::deserialize("RollbackTriggers", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RollbackConfigurationSerializer;
impl RollbackConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RollbackConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.monitoring_time_in_minutes {
params.put(
&format!("{}{}", prefix, "MonitoringTimeInMinutes"),
&field_value,
);
}
if let Some(ref field_value) = obj.rollback_triggers {
RollbackTriggersSerializer::serialize(
params,
&format!("{}{}", prefix, "RollbackTriggers"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RollbackTrigger {
pub arn: String,
pub type_: String,
}
#[allow(dead_code)]
struct RollbackTriggerDeserializer;
impl RollbackTriggerDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RollbackTrigger, XmlParseError> {
deserialize_elements::<_, RollbackTrigger, _>(tag_name, stack, |name, stack, obj| {
match name {
"Arn" => {
obj.arn = ArnDeserializer::deserialize("Arn", stack)?;
}
"Type" => {
obj.type_ = TypeDeserializer::deserialize("Type", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RollbackTriggerSerializer;
impl RollbackTriggerSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RollbackTrigger) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Arn"), &obj.arn);
params.put(&format!("{}{}", prefix, "Type"), &obj.type_);
}
}
#[allow(dead_code)]
struct RollbackTriggersDeserializer;
impl RollbackTriggersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RollbackTrigger>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(RollbackTriggerDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct RollbackTriggersSerializer;
impl RollbackTriggersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<RollbackTrigger>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
RollbackTriggerSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct ScopeDeserializer;
impl ScopeDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(ResourceAttributeDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetStackPolicyInput {
pub stack_name: String,
pub stack_policy_body: Option<String>,
pub stack_policy_url: Option<String>,
}
struct SetStackPolicyInputSerializer;
impl SetStackPolicyInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetStackPolicyInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
if let Some(ref field_value) = obj.stack_policy_body {
params.put(&format!("{}{}", prefix, "StackPolicyBody"), &field_value);
}
if let Some(ref field_value) = obj.stack_policy_url {
params.put(&format!("{}{}", prefix, "StackPolicyURL"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetTypeDefaultVersionInput {
pub arn: Option<String>,
pub type_: Option<String>,
pub type_name: Option<String>,
pub version_id: Option<String>,
}
struct SetTypeDefaultVersionInputSerializer;
impl SetTypeDefaultVersionInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetTypeDefaultVersionInput) {
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.type_ {
params.put(&format!("{}{}", prefix, "Type"), &field_value);
}
if let Some(ref field_value) = obj.type_name {
params.put(&format!("{}{}", prefix, "TypeName"), &field_value);
}
if let Some(ref field_value) = obj.version_id {
params.put(&format!("{}{}", prefix, "VersionId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SetTypeDefaultVersionOutput {}
#[allow(dead_code)]
struct SetTypeDefaultVersionOutputDeserializer;
impl SetTypeDefaultVersionOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SetTypeDefaultVersionOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = SetTypeDefaultVersionOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SignalResourceInput {
pub logical_resource_id: String,
pub stack_name: String,
pub status: String,
pub unique_id: String,
}
struct SignalResourceInputSerializer;
impl SignalResourceInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SignalResourceInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "LogicalResourceId"),
&obj.logical_resource_id,
);
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
params.put(&format!("{}{}", prefix, "Status"), &obj.status);
params.put(&format!("{}{}", prefix, "UniqueId"), &obj.unique_id);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Stack {
pub capabilities: Option<Vec<String>>,
pub change_set_id: Option<String>,
pub creation_time: String,
pub deletion_time: Option<String>,
pub description: Option<String>,
pub disable_rollback: Option<bool>,
pub drift_information: Option<StackDriftInformation>,
pub enable_termination_protection: Option<bool>,
pub last_updated_time: Option<String>,
pub notification_ar_ns: Option<Vec<String>>,
pub outputs: Option<Vec<Output>>,
pub parameters: Option<Vec<Parameter>>,
pub parent_id: Option<String>,
pub role_arn: Option<String>,
pub rollback_configuration: Option<RollbackConfiguration>,
pub root_id: Option<String>,
pub stack_id: Option<String>,
pub stack_name: String,
pub stack_status: String,
pub stack_status_reason: Option<String>,
pub tags: Option<Vec<Tag>>,
pub timeout_in_minutes: Option<i64>,
}
#[allow(dead_code)]
struct StackDeserializer;
impl StackDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Stack, XmlParseError> {
deserialize_elements::<_, Stack, _>(tag_name, stack, |name, stack, obj| {
match name {
"Capabilities" => {
obj.capabilities.get_or_insert(vec![]).extend(
CapabilitiesDeserializer::deserialize("Capabilities", stack)?,
);
}
"ChangeSetId" => {
obj.change_set_id =
Some(ChangeSetIdDeserializer::deserialize("ChangeSetId", stack)?);
}
"CreationTime" => {
obj.creation_time =
CreationTimeDeserializer::deserialize("CreationTime", stack)?;
}
"DeletionTime" => {
obj.deletion_time = Some(DeletionTimeDeserializer::deserialize(
"DeletionTime",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"DisableRollback" => {
obj.disable_rollback = Some(DisableRollbackDeserializer::deserialize(
"DisableRollback",
stack,
)?);
}
"DriftInformation" => {
obj.drift_information = Some(StackDriftInformationDeserializer::deserialize(
"DriftInformation",
stack,
)?);
}
"EnableTerminationProtection" => {
obj.enable_termination_protection =
Some(EnableTerminationProtectionDeserializer::deserialize(
"EnableTerminationProtection",
stack,
)?);
}
"LastUpdatedTime" => {
obj.last_updated_time = Some(LastUpdatedTimeDeserializer::deserialize(
"LastUpdatedTime",
stack,
)?);
}
"NotificationARNs" => {
obj.notification_ar_ns.get_or_insert(vec![]).extend(
NotificationARNsDeserializer::deserialize("NotificationARNs", stack)?,
);
}
"Outputs" => {
obj.outputs
.get_or_insert(vec![])
.extend(OutputsDeserializer::deserialize("Outputs", stack)?);
}
"Parameters" => {
obj.parameters
.get_or_insert(vec![])
.extend(ParametersDeserializer::deserialize("Parameters", stack)?);
}
"ParentId" => {
obj.parent_id = Some(StackIdDeserializer::deserialize("ParentId", stack)?);
}
"RoleARN" => {
obj.role_arn = Some(RoleARNDeserializer::deserialize("RoleARN", stack)?);
}
"RollbackConfiguration" => {
obj.rollback_configuration =
Some(RollbackConfigurationDeserializer::deserialize(
"RollbackConfiguration",
stack,
)?);
}
"RootId" => {
obj.root_id = Some(StackIdDeserializer::deserialize("RootId", stack)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackName" => {
obj.stack_name = StackNameDeserializer::deserialize("StackName", stack)?;
}
"StackStatus" => {
obj.stack_status = StackStatusDeserializer::deserialize("StackStatus", stack)?;
}
"StackStatusReason" => {
obj.stack_status_reason = Some(StackStatusReasonDeserializer::deserialize(
"StackStatusReason",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagsDeserializer::deserialize("Tags", stack)?);
}
"TimeoutInMinutes" => {
obj.timeout_in_minutes = Some(TimeoutMinutesDeserializer::deserialize(
"TimeoutInMinutes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackDriftDetectionIdDeserializer;
impl StackDriftDetectionIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackDriftDetectionStatusDeserializer;
impl StackDriftDetectionStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackDriftDetectionStatusReasonDeserializer;
impl StackDriftDetectionStatusReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackDriftInformation {
pub last_check_timestamp: Option<String>,
pub stack_drift_status: String,
}
#[allow(dead_code)]
struct StackDriftInformationDeserializer;
impl StackDriftInformationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackDriftInformation, XmlParseError> {
deserialize_elements::<_, StackDriftInformation, _>(tag_name, stack, |name, stack, obj| {
match name {
"LastCheckTimestamp" => {
obj.last_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastCheckTimestamp",
stack,
)?);
}
"StackDriftStatus" => {
obj.stack_drift_status =
StackDriftStatusDeserializer::deserialize("StackDriftStatus", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackDriftInformationSummary {
pub last_check_timestamp: Option<String>,
pub stack_drift_status: String,
}
#[allow(dead_code)]
struct StackDriftInformationSummaryDeserializer;
impl StackDriftInformationSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackDriftInformationSummary, XmlParseError> {
deserialize_elements::<_, StackDriftInformationSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"LastCheckTimestamp" => {
obj.last_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastCheckTimestamp",
stack,
)?);
}
"StackDriftStatus" => {
obj.stack_drift_status =
StackDriftStatusDeserializer::deserialize("StackDriftStatus", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StackDriftStatusDeserializer;
impl StackDriftStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackEvent {
pub client_request_token: Option<String>,
pub event_id: String,
pub logical_resource_id: Option<String>,
pub physical_resource_id: Option<String>,
pub resource_properties: Option<String>,
pub resource_status: Option<String>,
pub resource_status_reason: Option<String>,
pub resource_type: Option<String>,
pub stack_id: String,
pub stack_name: String,
pub timestamp: String,
}
#[allow(dead_code)]
struct StackEventDeserializer;
impl StackEventDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackEvent, XmlParseError> {
deserialize_elements::<_, StackEvent, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClientRequestToken" => {
obj.client_request_token = Some(ClientRequestTokenDeserializer::deserialize(
"ClientRequestToken",
stack,
)?);
}
"EventId" => {
obj.event_id = EventIdDeserializer::deserialize("EventId", stack)?;
}
"LogicalResourceId" => {
obj.logical_resource_id = Some(LogicalResourceIdDeserializer::deserialize(
"LogicalResourceId",
stack,
)?);
}
"PhysicalResourceId" => {
obj.physical_resource_id = Some(PhysicalResourceIdDeserializer::deserialize(
"PhysicalResourceId",
stack,
)?);
}
"ResourceProperties" => {
obj.resource_properties = Some(ResourcePropertiesDeserializer::deserialize(
"ResourceProperties",
stack,
)?);
}
"ResourceStatus" => {
obj.resource_status = Some(ResourceStatusDeserializer::deserialize(
"ResourceStatus",
stack,
)?);
}
"ResourceStatusReason" => {
obj.resource_status_reason =
Some(ResourceStatusReasonDeserializer::deserialize(
"ResourceStatusReason",
stack,
)?);
}
"ResourceType" => {
obj.resource_type = Some(ResourceTypeDeserializer::deserialize(
"ResourceType",
stack,
)?);
}
"StackId" => {
obj.stack_id = StackIdDeserializer::deserialize("StackId", stack)?;
}
"StackName" => {
obj.stack_name = StackNameDeserializer::deserialize("StackName", stack)?;
}
"Timestamp" => {
obj.timestamp = TimestampDeserializer::deserialize("Timestamp", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackEventsDeserializer;
impl StackEventsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackEvent>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackEventDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackIdDeserializer;
impl StackIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackInstance {
pub account: Option<String>,
pub drift_status: Option<String>,
pub last_drift_check_timestamp: Option<String>,
pub organizational_unit_id: Option<String>,
pub parameter_overrides: Option<Vec<Parameter>>,
pub region: Option<String>,
pub stack_id: Option<String>,
pub stack_instance_status: Option<StackInstanceComprehensiveStatus>,
pub stack_set_id: Option<String>,
pub status: Option<String>,
pub status_reason: Option<String>,
}
#[allow(dead_code)]
struct StackInstanceDeserializer;
impl StackInstanceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackInstance, XmlParseError> {
deserialize_elements::<_, StackInstance, _>(tag_name, stack, |name, stack, obj| {
match name {
"Account" => {
obj.account = Some(AccountDeserializer::deserialize("Account", stack)?);
}
"DriftStatus" => {
obj.drift_status = Some(StackDriftStatusDeserializer::deserialize(
"DriftStatus",
stack,
)?);
}
"LastDriftCheckTimestamp" => {
obj.last_drift_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastDriftCheckTimestamp",
stack,
)?);
}
"OrganizationalUnitId" => {
obj.organizational_unit_id =
Some(OrganizationalUnitIdDeserializer::deserialize(
"OrganizationalUnitId",
stack,
)?);
}
"ParameterOverrides" => {
obj.parameter_overrides.get_or_insert(vec![]).extend(
ParametersDeserializer::deserialize("ParameterOverrides", stack)?,
);
}
"Region" => {
obj.region = Some(RegionDeserializer::deserialize("Region", stack)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackInstanceStatus" => {
obj.stack_instance_status =
Some(StackInstanceComprehensiveStatusDeserializer::deserialize(
"StackInstanceStatus",
stack,
)?);
}
"StackSetId" => {
obj.stack_set_id =
Some(StackSetIdDeserializer::deserialize("StackSetId", stack)?);
}
"Status" => {
obj.status = Some(StackInstanceStatusDeserializer::deserialize(
"Status", stack,
)?);
}
"StatusReason" => {
obj.status_reason =
Some(ReasonDeserializer::deserialize("StatusReason", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackInstanceComprehensiveStatus {
pub detailed_status: Option<String>,
}
#[allow(dead_code)]
struct StackInstanceComprehensiveStatusDeserializer;
impl StackInstanceComprehensiveStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackInstanceComprehensiveStatus, XmlParseError> {
deserialize_elements::<_, StackInstanceComprehensiveStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DetailedStatus" => {
obj.detailed_status =
Some(StackInstanceDetailedStatusDeserializer::deserialize(
"DetailedStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StackInstanceDetailedStatusDeserializer;
impl StackInstanceDetailedStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StackInstanceFilter {
pub name: Option<String>,
pub values: Option<String>,
}
struct StackInstanceFilterSerializer;
impl StackInstanceFilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StackInstanceFilter) {
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 {
params.put(&format!("{}{}", prefix, "Values"), &field_value);
}
}
}
struct StackInstanceFiltersSerializer;
impl StackInstanceFiltersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<StackInstanceFilter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
StackInstanceFilterSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct StackInstanceStatusDeserializer;
impl StackInstanceStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackInstanceSummariesDeserializer;
impl StackInstanceSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackInstanceSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackInstanceSummaryDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackInstanceSummary {
pub account: Option<String>,
pub drift_status: Option<String>,
pub last_drift_check_timestamp: Option<String>,
pub organizational_unit_id: Option<String>,
pub region: Option<String>,
pub stack_id: Option<String>,
pub stack_instance_status: Option<StackInstanceComprehensiveStatus>,
pub stack_set_id: Option<String>,
pub status: Option<String>,
pub status_reason: Option<String>,
}
#[allow(dead_code)]
struct StackInstanceSummaryDeserializer;
impl StackInstanceSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackInstanceSummary, XmlParseError> {
deserialize_elements::<_, StackInstanceSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"Account" => {
obj.account = Some(AccountDeserializer::deserialize("Account", stack)?);
}
"DriftStatus" => {
obj.drift_status = Some(StackDriftStatusDeserializer::deserialize(
"DriftStatus",
stack,
)?);
}
"LastDriftCheckTimestamp" => {
obj.last_drift_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastDriftCheckTimestamp",
stack,
)?);
}
"OrganizationalUnitId" => {
obj.organizational_unit_id =
Some(OrganizationalUnitIdDeserializer::deserialize(
"OrganizationalUnitId",
stack,
)?);
}
"Region" => {
obj.region = Some(RegionDeserializer::deserialize("Region", stack)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackInstanceStatus" => {
obj.stack_instance_status =
Some(StackInstanceComprehensiveStatusDeserializer::deserialize(
"StackInstanceStatus",
stack,
)?);
}
"StackSetId" => {
obj.stack_set_id =
Some(StackSetIdDeserializer::deserialize("StackSetId", stack)?);
}
"Status" => {
obj.status = Some(StackInstanceStatusDeserializer::deserialize(
"Status", stack,
)?);
}
"StatusReason" => {
obj.status_reason =
Some(ReasonDeserializer::deserialize("StatusReason", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackNameDeserializer;
impl StackNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackPolicyBodyDeserializer;
impl StackPolicyBodyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackResource {
pub description: Option<String>,
pub drift_information: Option<StackResourceDriftInformation>,
pub logical_resource_id: String,
pub physical_resource_id: Option<String>,
pub resource_status: String,
pub resource_status_reason: Option<String>,
pub resource_type: String,
pub stack_id: Option<String>,
pub stack_name: Option<String>,
pub timestamp: String,
}
#[allow(dead_code)]
struct StackResourceDeserializer;
impl StackResourceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackResource, XmlParseError> {
deserialize_elements::<_, StackResource, _>(tag_name, stack, |name, stack, obj| {
match name {
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"DriftInformation" => {
obj.drift_information =
Some(StackResourceDriftInformationDeserializer::deserialize(
"DriftInformation",
stack,
)?);
}
"LogicalResourceId" => {
obj.logical_resource_id =
LogicalResourceIdDeserializer::deserialize("LogicalResourceId", stack)?;
}
"PhysicalResourceId" => {
obj.physical_resource_id = Some(PhysicalResourceIdDeserializer::deserialize(
"PhysicalResourceId",
stack,
)?);
}
"ResourceStatus" => {
obj.resource_status =
ResourceStatusDeserializer::deserialize("ResourceStatus", stack)?;
}
"ResourceStatusReason" => {
obj.resource_status_reason =
Some(ResourceStatusReasonDeserializer::deserialize(
"ResourceStatusReason",
stack,
)?);
}
"ResourceType" => {
obj.resource_type =
ResourceTypeDeserializer::deserialize("ResourceType", stack)?;
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackName" => {
obj.stack_name = Some(StackNameDeserializer::deserialize("StackName", stack)?);
}
"Timestamp" => {
obj.timestamp = TimestampDeserializer::deserialize("Timestamp", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackResourceDetail {
pub description: Option<String>,
pub drift_information: Option<StackResourceDriftInformation>,
pub last_updated_timestamp: String,
pub logical_resource_id: String,
pub metadata: Option<String>,
pub physical_resource_id: Option<String>,
pub resource_status: String,
pub resource_status_reason: Option<String>,
pub resource_type: String,
pub stack_id: Option<String>,
pub stack_name: Option<String>,
}
#[allow(dead_code)]
struct StackResourceDetailDeserializer;
impl StackResourceDetailDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackResourceDetail, XmlParseError> {
deserialize_elements::<_, StackResourceDetail, _>(tag_name, stack, |name, stack, obj| {
match name {
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"DriftInformation" => {
obj.drift_information =
Some(StackResourceDriftInformationDeserializer::deserialize(
"DriftInformation",
stack,
)?);
}
"LastUpdatedTimestamp" => {
obj.last_updated_timestamp =
TimestampDeserializer::deserialize("LastUpdatedTimestamp", stack)?;
}
"LogicalResourceId" => {
obj.logical_resource_id =
LogicalResourceIdDeserializer::deserialize("LogicalResourceId", stack)?;
}
"Metadata" => {
obj.metadata = Some(MetadataDeserializer::deserialize("Metadata", stack)?);
}
"PhysicalResourceId" => {
obj.physical_resource_id = Some(PhysicalResourceIdDeserializer::deserialize(
"PhysicalResourceId",
stack,
)?);
}
"ResourceStatus" => {
obj.resource_status =
ResourceStatusDeserializer::deserialize("ResourceStatus", stack)?;
}
"ResourceStatusReason" => {
obj.resource_status_reason =
Some(ResourceStatusReasonDeserializer::deserialize(
"ResourceStatusReason",
stack,
)?);
}
"ResourceType" => {
obj.resource_type =
ResourceTypeDeserializer::deserialize("ResourceType", stack)?;
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackName" => {
obj.stack_name = Some(StackNameDeserializer::deserialize("StackName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackResourceDrift {
pub actual_properties: Option<String>,
pub expected_properties: Option<String>,
pub logical_resource_id: String,
pub physical_resource_id: Option<String>,
pub physical_resource_id_context: Option<Vec<PhysicalResourceIdContextKeyValuePair>>,
pub property_differences: Option<Vec<PropertyDifference>>,
pub resource_type: String,
pub stack_id: String,
pub stack_resource_drift_status: String,
pub timestamp: String,
}
#[allow(dead_code)]
struct StackResourceDriftDeserializer;
impl StackResourceDriftDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackResourceDrift, XmlParseError> {
deserialize_elements::<_, StackResourceDrift, _>(tag_name, stack, |name, stack, obj| {
match name {
"ActualProperties" => {
obj.actual_properties = Some(PropertiesDeserializer::deserialize(
"ActualProperties",
stack,
)?);
}
"ExpectedProperties" => {
obj.expected_properties = Some(PropertiesDeserializer::deserialize(
"ExpectedProperties",
stack,
)?);
}
"LogicalResourceId" => {
obj.logical_resource_id =
LogicalResourceIdDeserializer::deserialize("LogicalResourceId", stack)?;
}
"PhysicalResourceId" => {
obj.physical_resource_id = Some(PhysicalResourceIdDeserializer::deserialize(
"PhysicalResourceId",
stack,
)?);
}
"PhysicalResourceIdContext" => {
obj.physical_resource_id_context
.get_or_insert(vec![])
.extend(PhysicalResourceIdContextDeserializer::deserialize(
"PhysicalResourceIdContext",
stack,
)?);
}
"PropertyDifferences" => {
obj.property_differences.get_or_insert(vec![]).extend(
PropertyDifferencesDeserializer::deserialize("PropertyDifferences", stack)?,
);
}
"ResourceType" => {
obj.resource_type =
ResourceTypeDeserializer::deserialize("ResourceType", stack)?;
}
"StackId" => {
obj.stack_id = StackIdDeserializer::deserialize("StackId", stack)?;
}
"StackResourceDriftStatus" => {
obj.stack_resource_drift_status =
StackResourceDriftStatusDeserializer::deserialize(
"StackResourceDriftStatus",
stack,
)?;
}
"Timestamp" => {
obj.timestamp = TimestampDeserializer::deserialize("Timestamp", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackResourceDriftInformation {
pub last_check_timestamp: Option<String>,
pub stack_resource_drift_status: String,
}
#[allow(dead_code)]
struct StackResourceDriftInformationDeserializer;
impl StackResourceDriftInformationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackResourceDriftInformation, XmlParseError> {
deserialize_elements::<_, StackResourceDriftInformation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"LastCheckTimestamp" => {
obj.last_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastCheckTimestamp",
stack,
)?);
}
"StackResourceDriftStatus" => {
obj.stack_resource_drift_status =
StackResourceDriftStatusDeserializer::deserialize(
"StackResourceDriftStatus",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackResourceDriftInformationSummary {
pub last_check_timestamp: Option<String>,
pub stack_resource_drift_status: String,
}
#[allow(dead_code)]
struct StackResourceDriftInformationSummaryDeserializer;
impl StackResourceDriftInformationSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackResourceDriftInformationSummary, XmlParseError> {
deserialize_elements::<_, StackResourceDriftInformationSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"LastCheckTimestamp" => {
obj.last_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastCheckTimestamp",
stack,
)?);
}
"StackResourceDriftStatus" => {
obj.stack_resource_drift_status =
StackResourceDriftStatusDeserializer::deserialize(
"StackResourceDriftStatus",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StackResourceDriftStatusDeserializer;
impl StackResourceDriftStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct StackResourceDriftStatusFiltersSerializer;
impl StackResourceDriftStatusFiltersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct StackResourceDriftsDeserializer;
impl StackResourceDriftsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackResourceDrift>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackResourceDriftDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackResourceSummariesDeserializer;
impl StackResourceSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackResourceSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackResourceSummaryDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackResourceSummary {
pub drift_information: Option<StackResourceDriftInformationSummary>,
pub last_updated_timestamp: String,
pub logical_resource_id: String,
pub physical_resource_id: Option<String>,
pub resource_status: String,
pub resource_status_reason: Option<String>,
pub resource_type: String,
}
#[allow(dead_code)]
struct StackResourceSummaryDeserializer;
impl StackResourceSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackResourceSummary, XmlParseError> {
deserialize_elements::<_, StackResourceSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"DriftInformation" => {
obj.drift_information = Some(
StackResourceDriftInformationSummaryDeserializer::deserialize(
"DriftInformation",
stack,
)?,
);
}
"LastUpdatedTimestamp" => {
obj.last_updated_timestamp =
TimestampDeserializer::deserialize("LastUpdatedTimestamp", stack)?;
}
"LogicalResourceId" => {
obj.logical_resource_id =
LogicalResourceIdDeserializer::deserialize("LogicalResourceId", stack)?;
}
"PhysicalResourceId" => {
obj.physical_resource_id = Some(PhysicalResourceIdDeserializer::deserialize(
"PhysicalResourceId",
stack,
)?);
}
"ResourceStatus" => {
obj.resource_status =
ResourceStatusDeserializer::deserialize("ResourceStatus", stack)?;
}
"ResourceStatusReason" => {
obj.resource_status_reason =
Some(ResourceStatusReasonDeserializer::deserialize(
"ResourceStatusReason",
stack,
)?);
}
"ResourceType" => {
obj.resource_type =
ResourceTypeDeserializer::deserialize("ResourceType", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackResourcesDeserializer;
impl StackResourcesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackResource>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackResourceDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSet {
pub administration_role_arn: Option<String>,
pub auto_deployment: Option<AutoDeployment>,
pub capabilities: Option<Vec<String>>,
pub description: Option<String>,
pub execution_role_name: Option<String>,
pub organizational_unit_ids: Option<Vec<String>>,
pub parameters: Option<Vec<Parameter>>,
pub permission_model: Option<String>,
pub stack_set_arn: Option<String>,
pub stack_set_drift_detection_details: Option<StackSetDriftDetectionDetails>,
pub stack_set_id: Option<String>,
pub stack_set_name: Option<String>,
pub status: Option<String>,
pub tags: Option<Vec<Tag>>,
pub template_body: Option<String>,
}
#[allow(dead_code)]
struct StackSetDeserializer;
impl StackSetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSet, XmlParseError> {
deserialize_elements::<_, StackSet, _>(tag_name, stack, |name, stack, obj| {
match name {
"AdministrationRoleARN" => {
obj.administration_role_arn = Some(RoleARNDeserializer::deserialize(
"AdministrationRoleARN",
stack,
)?);
}
"AutoDeployment" => {
obj.auto_deployment = Some(AutoDeploymentDeserializer::deserialize(
"AutoDeployment",
stack,
)?);
}
"Capabilities" => {
obj.capabilities.get_or_insert(vec![]).extend(
CapabilitiesDeserializer::deserialize("Capabilities", stack)?,
);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"ExecutionRoleName" => {
obj.execution_role_name = Some(ExecutionRoleNameDeserializer::deserialize(
"ExecutionRoleName",
stack,
)?);
}
"OrganizationalUnitIds" => {
obj.organizational_unit_ids.get_or_insert(vec![]).extend(
OrganizationalUnitIdListDeserializer::deserialize(
"OrganizationalUnitIds",
stack,
)?,
);
}
"Parameters" => {
obj.parameters
.get_or_insert(vec![])
.extend(ParametersDeserializer::deserialize("Parameters", stack)?);
}
"PermissionModel" => {
obj.permission_model = Some(PermissionModelsDeserializer::deserialize(
"PermissionModel",
stack,
)?);
}
"StackSetARN" => {
obj.stack_set_arn =
Some(StackSetARNDeserializer::deserialize("StackSetARN", stack)?);
}
"StackSetDriftDetectionDetails" => {
obj.stack_set_drift_detection_details =
Some(StackSetDriftDetectionDetailsDeserializer::deserialize(
"StackSetDriftDetectionDetails",
stack,
)?);
}
"StackSetId" => {
obj.stack_set_id =
Some(StackSetIdDeserializer::deserialize("StackSetId", stack)?);
}
"StackSetName" => {
obj.stack_set_name = Some(StackSetNameDeserializer::deserialize(
"StackSetName",
stack,
)?);
}
"Status" => {
obj.status = Some(StackSetStatusDeserializer::deserialize("Status", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagsDeserializer::deserialize("Tags", stack)?);
}
"TemplateBody" => {
obj.template_body = Some(TemplateBodyDeserializer::deserialize(
"TemplateBody",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackSetARNDeserializer;
impl StackSetARNDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSetDriftDetectionDetails {
pub drift_detection_status: Option<String>,
pub drift_status: Option<String>,
pub drifted_stack_instances_count: Option<i64>,
pub failed_stack_instances_count: Option<i64>,
pub in_progress_stack_instances_count: Option<i64>,
pub in_sync_stack_instances_count: Option<i64>,
pub last_drift_check_timestamp: Option<String>,
pub total_stack_instances_count: Option<i64>,
}
#[allow(dead_code)]
struct StackSetDriftDetectionDetailsDeserializer;
impl StackSetDriftDetectionDetailsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSetDriftDetectionDetails, XmlParseError> {
deserialize_elements::<_, StackSetDriftDetectionDetails, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DriftDetectionStatus" => {
obj.drift_detection_status =
Some(StackSetDriftDetectionStatusDeserializer::deserialize(
"DriftDetectionStatus",
stack,
)?);
}
"DriftStatus" => {
obj.drift_status = Some(StackSetDriftStatusDeserializer::deserialize(
"DriftStatus",
stack,
)?);
}
"DriftedStackInstancesCount" => {
obj.drifted_stack_instances_count =
Some(DriftedStackInstancesCountDeserializer::deserialize(
"DriftedStackInstancesCount",
stack,
)?);
}
"FailedStackInstancesCount" => {
obj.failed_stack_instances_count =
Some(FailedStackInstancesCountDeserializer::deserialize(
"FailedStackInstancesCount",
stack,
)?);
}
"InProgressStackInstancesCount" => {
obj.in_progress_stack_instances_count =
Some(InProgressStackInstancesCountDeserializer::deserialize(
"InProgressStackInstancesCount",
stack,
)?);
}
"InSyncStackInstancesCount" => {
obj.in_sync_stack_instances_count =
Some(InSyncStackInstancesCountDeserializer::deserialize(
"InSyncStackInstancesCount",
stack,
)?);
}
"LastDriftCheckTimestamp" => {
obj.last_drift_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastDriftCheckTimestamp",
stack,
)?);
}
"TotalStackInstancesCount" => {
obj.total_stack_instances_count =
Some(TotalStackInstancesCountDeserializer::deserialize(
"TotalStackInstancesCount",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StackSetDriftDetectionStatusDeserializer;
impl StackSetDriftDetectionStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSetDriftStatusDeserializer;
impl StackSetDriftStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSetIdDeserializer;
impl StackSetIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSetNameDeserializer;
impl StackSetNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSetOperation {
pub action: Option<String>,
pub administration_role_arn: Option<String>,
pub creation_timestamp: Option<String>,
pub deployment_targets: Option<DeploymentTargets>,
pub end_timestamp: Option<String>,
pub execution_role_name: Option<String>,
pub operation_id: Option<String>,
pub operation_preferences: Option<StackSetOperationPreferences>,
pub retain_stacks: Option<bool>,
pub stack_set_drift_detection_details: Option<StackSetDriftDetectionDetails>,
pub stack_set_id: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct StackSetOperationDeserializer;
impl StackSetOperationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSetOperation, XmlParseError> {
deserialize_elements::<_, StackSetOperation, _>(tag_name, stack, |name, stack, obj| {
match name {
"Action" => {
obj.action = Some(StackSetOperationActionDeserializer::deserialize(
"Action", stack,
)?);
}
"AdministrationRoleARN" => {
obj.administration_role_arn = Some(RoleARNDeserializer::deserialize(
"AdministrationRoleARN",
stack,
)?);
}
"CreationTimestamp" => {
obj.creation_timestamp = Some(TimestampDeserializer::deserialize(
"CreationTimestamp",
stack,
)?);
}
"DeploymentTargets" => {
obj.deployment_targets = Some(DeploymentTargetsDeserializer::deserialize(
"DeploymentTargets",
stack,
)?);
}
"EndTimestamp" => {
obj.end_timestamp =
Some(TimestampDeserializer::deserialize("EndTimestamp", stack)?);
}
"ExecutionRoleName" => {
obj.execution_role_name = Some(ExecutionRoleNameDeserializer::deserialize(
"ExecutionRoleName",
stack,
)?);
}
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
"OperationPreferences" => {
obj.operation_preferences =
Some(StackSetOperationPreferencesDeserializer::deserialize(
"OperationPreferences",
stack,
)?);
}
"RetainStacks" => {
obj.retain_stacks = Some(RetainStacksNullableDeserializer::deserialize(
"RetainStacks",
stack,
)?);
}
"StackSetDriftDetectionDetails" => {
obj.stack_set_drift_detection_details =
Some(StackSetDriftDetectionDetailsDeserializer::deserialize(
"StackSetDriftDetectionDetails",
stack,
)?);
}
"StackSetId" => {
obj.stack_set_id =
Some(StackSetIdDeserializer::deserialize("StackSetId", stack)?);
}
"Status" => {
obj.status = Some(StackSetOperationStatusDeserializer::deserialize(
"Status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackSetOperationActionDeserializer;
impl StackSetOperationActionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StackSetOperationPreferences {
pub failure_tolerance_count: Option<i64>,
pub failure_tolerance_percentage: Option<i64>,
pub max_concurrent_count: Option<i64>,
pub max_concurrent_percentage: Option<i64>,
pub region_order: Option<Vec<String>>,
}
#[allow(dead_code)]
struct StackSetOperationPreferencesDeserializer;
impl StackSetOperationPreferencesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSetOperationPreferences, XmlParseError> {
deserialize_elements::<_, StackSetOperationPreferences, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"FailureToleranceCount" => {
obj.failure_tolerance_count =
Some(FailureToleranceCountDeserializer::deserialize(
"FailureToleranceCount",
stack,
)?);
}
"FailureTolerancePercentage" => {
obj.failure_tolerance_percentage =
Some(FailureTolerancePercentageDeserializer::deserialize(
"FailureTolerancePercentage",
stack,
)?);
}
"MaxConcurrentCount" => {
obj.max_concurrent_count =
Some(MaxConcurrentCountDeserializer::deserialize(
"MaxConcurrentCount",
stack,
)?);
}
"MaxConcurrentPercentage" => {
obj.max_concurrent_percentage =
Some(MaxConcurrentPercentageDeserializer::deserialize(
"MaxConcurrentPercentage",
stack,
)?);
}
"RegionOrder" => {
obj.region_order
.get_or_insert(vec![])
.extend(RegionListDeserializer::deserialize("RegionOrder", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct StackSetOperationPreferencesSerializer;
impl StackSetOperationPreferencesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StackSetOperationPreferences) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.failure_tolerance_count {
params.put(
&format!("{}{}", prefix, "FailureToleranceCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.failure_tolerance_percentage {
params.put(
&format!("{}{}", prefix, "FailureTolerancePercentage"),
&field_value,
);
}
if let Some(ref field_value) = obj.max_concurrent_count {
params.put(&format!("{}{}", prefix, "MaxConcurrentCount"), &field_value);
}
if let Some(ref field_value) = obj.max_concurrent_percentage {
params.put(
&format!("{}{}", prefix, "MaxConcurrentPercentage"),
&field_value,
);
}
if let Some(ref field_value) = obj.region_order {
RegionListSerializer::serialize(
params,
&format!("{}{}", prefix, "RegionOrder"),
field_value,
);
}
}
}
#[allow(dead_code)]
struct StackSetOperationResultStatusDeserializer;
impl StackSetOperationResultStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSetOperationResultSummariesDeserializer;
impl StackSetOperationResultSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackSetOperationResultSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackSetOperationResultSummaryDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSetOperationResultSummary {
pub account: Option<String>,
pub account_gate_result: Option<AccountGateResult>,
pub organizational_unit_id: Option<String>,
pub region: Option<String>,
pub status: Option<String>,
pub status_reason: Option<String>,
}
#[allow(dead_code)]
struct StackSetOperationResultSummaryDeserializer;
impl StackSetOperationResultSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSetOperationResultSummary, XmlParseError> {
deserialize_elements::<_, StackSetOperationResultSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Account" => {
obj.account = Some(AccountDeserializer::deserialize("Account", stack)?);
}
"AccountGateResult" => {
obj.account_gate_result = Some(AccountGateResultDeserializer::deserialize(
"AccountGateResult",
stack,
)?);
}
"OrganizationalUnitId" => {
obj.organizational_unit_id =
Some(OrganizationalUnitIdDeserializer::deserialize(
"OrganizationalUnitId",
stack,
)?);
}
"Region" => {
obj.region = Some(RegionDeserializer::deserialize("Region", stack)?);
}
"Status" => {
obj.status = Some(StackSetOperationResultStatusDeserializer::deserialize(
"Status", stack,
)?);
}
"StatusReason" => {
obj.status_reason =
Some(ReasonDeserializer::deserialize("StatusReason", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StackSetOperationStatusDeserializer;
impl StackSetOperationStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSetOperationSummariesDeserializer;
impl StackSetOperationSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackSetOperationSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackSetOperationSummaryDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSetOperationSummary {
pub action: Option<String>,
pub creation_timestamp: Option<String>,
pub end_timestamp: Option<String>,
pub operation_id: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct StackSetOperationSummaryDeserializer;
impl StackSetOperationSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSetOperationSummary, XmlParseError> {
deserialize_elements::<_, StackSetOperationSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Action" => {
obj.action = Some(StackSetOperationActionDeserializer::deserialize(
"Action", stack,
)?);
}
"CreationTimestamp" => {
obj.creation_timestamp = Some(TimestampDeserializer::deserialize(
"CreationTimestamp",
stack,
)?);
}
"EndTimestamp" => {
obj.end_timestamp =
Some(TimestampDeserializer::deserialize("EndTimestamp", stack)?);
}
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
"Status" => {
obj.status = Some(StackSetOperationStatusDeserializer::deserialize(
"Status", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StackSetStatusDeserializer;
impl StackSetStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSetSummariesDeserializer;
impl StackSetSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackSetSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackSetSummaryDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSetSummary {
pub auto_deployment: Option<AutoDeployment>,
pub description: Option<String>,
pub drift_status: Option<String>,
pub last_drift_check_timestamp: Option<String>,
pub permission_model: Option<String>,
pub stack_set_id: Option<String>,
pub stack_set_name: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct StackSetSummaryDeserializer;
impl StackSetSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSetSummary, XmlParseError> {
deserialize_elements::<_, StackSetSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"AutoDeployment" => {
obj.auto_deployment = Some(AutoDeploymentDeserializer::deserialize(
"AutoDeployment",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"DriftStatus" => {
obj.drift_status = Some(StackDriftStatusDeserializer::deserialize(
"DriftStatus",
stack,
)?);
}
"LastDriftCheckTimestamp" => {
obj.last_drift_check_timestamp = Some(TimestampDeserializer::deserialize(
"LastDriftCheckTimestamp",
stack,
)?);
}
"PermissionModel" => {
obj.permission_model = Some(PermissionModelsDeserializer::deserialize(
"PermissionModel",
stack,
)?);
}
"StackSetId" => {
obj.stack_set_id =
Some(StackSetIdDeserializer::deserialize("StackSetId", stack)?);
}
"StackSetName" => {
obj.stack_set_name = Some(StackSetNameDeserializer::deserialize(
"StackSetName",
stack,
)?);
}
"Status" => {
obj.status = Some(StackSetStatusDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StackStatusDeserializer;
impl StackStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct StackStatusFilterSerializer;
impl StackStatusFilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct StackStatusReasonDeserializer;
impl StackStatusReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StackSummariesDeserializer;
impl StackSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StackSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackSummaryDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StackSummary {
pub creation_time: String,
pub deletion_time: Option<String>,
pub drift_information: Option<StackDriftInformationSummary>,
pub last_updated_time: Option<String>,
pub parent_id: Option<String>,
pub root_id: Option<String>,
pub stack_id: Option<String>,
pub stack_name: String,
pub stack_status: String,
pub stack_status_reason: Option<String>,
pub template_description: Option<String>,
}
#[allow(dead_code)]
struct StackSummaryDeserializer;
impl StackSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StackSummary, XmlParseError> {
deserialize_elements::<_, StackSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"CreationTime" => {
obj.creation_time =
CreationTimeDeserializer::deserialize("CreationTime", stack)?;
}
"DeletionTime" => {
obj.deletion_time = Some(DeletionTimeDeserializer::deserialize(
"DeletionTime",
stack,
)?);
}
"DriftInformation" => {
obj.drift_information =
Some(StackDriftInformationSummaryDeserializer::deserialize(
"DriftInformation",
stack,
)?);
}
"LastUpdatedTime" => {
obj.last_updated_time = Some(LastUpdatedTimeDeserializer::deserialize(
"LastUpdatedTime",
stack,
)?);
}
"ParentId" => {
obj.parent_id = Some(StackIdDeserializer::deserialize("ParentId", stack)?);
}
"RootId" => {
obj.root_id = Some(StackIdDeserializer::deserialize("RootId", stack)?);
}
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
"StackName" => {
obj.stack_name = StackNameDeserializer::deserialize("StackName", stack)?;
}
"StackStatus" => {
obj.stack_status = StackStatusDeserializer::deserialize("StackStatus", stack)?;
}
"StackStatusReason" => {
obj.stack_status_reason = Some(StackStatusReasonDeserializer::deserialize(
"StackStatusReason",
stack,
)?);
}
"TemplateDescription" => {
obj.template_description = Some(TemplateDescriptionDeserializer::deserialize(
"TemplateDescription",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StacksDeserializer;
impl StacksDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Stack>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StackDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StageListDeserializer;
impl StageListDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(TemplateStageDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopStackSetOperationInput {
pub operation_id: String,
pub stack_set_name: String,
}
struct StopStackSetOperationInputSerializer;
impl StopStackSetOperationInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StopStackSetOperationInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "OperationId"), &obj.operation_id);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StopStackSetOperationOutput {}
#[allow(dead_code)]
struct StopStackSetOperationOutputDeserializer;
impl StopStackSetOperationOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StopStackSetOperationOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = StopStackSetOperationOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tag {
pub key: String,
pub value: String,
}
#[allow(dead_code)]
struct TagDeserializer;
impl TagDeserializer {
#[allow(dead_code, 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 = TagKeyDeserializer::deserialize("Key", stack)?;
}
"Value" => {
obj.value = TagValueDeserializer::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(".");
}
params.put(&format!("{}{}", prefix, "Key"), &obj.key);
params.put(&format!("{}{}", prefix, "Value"), &obj.value);
}
}
#[allow(dead_code)]
struct TagKeyDeserializer;
impl TagKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TagValueDeserializer;
impl TagValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TagsDeserializer;
impl TagsDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(TagDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TagsSerializer;
impl TagsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Tag>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
TagSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct TemplateBodyDeserializer;
impl TemplateBodyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TemplateDescriptionDeserializer;
impl TemplateDescriptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TemplateParameter {
pub default_value: Option<String>,
pub description: Option<String>,
pub no_echo: Option<bool>,
pub parameter_key: Option<String>,
}
#[allow(dead_code)]
struct TemplateParameterDeserializer;
impl TemplateParameterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TemplateParameter, XmlParseError> {
deserialize_elements::<_, TemplateParameter, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value = Some(ParameterValueDeserializer::deserialize(
"DefaultValue",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"NoEcho" => {
obj.no_echo = Some(NoEchoDeserializer::deserialize("NoEcho", stack)?);
}
"ParameterKey" => {
obj.parameter_key = Some(ParameterKeyDeserializer::deserialize(
"ParameterKey",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TemplateParametersDeserializer;
impl TemplateParametersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TemplateParameter>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TemplateParameterDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TemplateStageDeserializer;
impl TemplateStageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TimeoutMinutesDeserializer;
impl TimeoutMinutesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct TimestampDeserializer;
impl TimestampDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TotalStackInstancesCountDeserializer;
impl TotalStackInstancesCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct TransformNameDeserializer;
impl TransformNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TransformsListDeserializer;
impl TransformsListDeserializer {
#[allow(dead_code, 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 == "member" {
obj.push(TransformNameDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TypeDeserializer;
impl TypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TypeArnDeserializer;
impl TypeArnDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TypeNameDeserializer;
impl TypeNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TypeSchemaDeserializer;
impl TypeSchemaDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TypeSummariesDeserializer;
impl TypeSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TypeSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TypeSummaryDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TypeSummary {
pub default_version_id: Option<String>,
pub description: Option<String>,
pub last_updated: Option<String>,
pub type_: Option<String>,
pub type_arn: Option<String>,
pub type_name: Option<String>,
}
#[allow(dead_code)]
struct TypeSummaryDeserializer;
impl TypeSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TypeSummary, XmlParseError> {
deserialize_elements::<_, TypeSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultVersionId" => {
obj.default_version_id = Some(TypeVersionIdDeserializer::deserialize(
"DefaultVersionId",
stack,
)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"LastUpdated" => {
obj.last_updated =
Some(TimestampDeserializer::deserialize("LastUpdated", stack)?);
}
"Type" => {
obj.type_ = Some(RegistryTypeDeserializer::deserialize("Type", stack)?);
}
"TypeArn" => {
obj.type_arn = Some(TypeArnDeserializer::deserialize("TypeArn", stack)?);
}
"TypeName" => {
obj.type_name = Some(TypeNameDeserializer::deserialize("TypeName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TypeVersionIdDeserializer;
impl TypeVersionIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TypeVersionSummariesDeserializer;
impl TypeVersionSummariesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TypeVersionSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TypeVersionSummaryDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TypeVersionSummary {
pub arn: Option<String>,
pub description: Option<String>,
pub is_default_version: Option<bool>,
pub time_created: Option<String>,
pub type_: Option<String>,
pub type_name: Option<String>,
pub version_id: Option<String>,
}
#[allow(dead_code)]
struct TypeVersionSummaryDeserializer;
impl TypeVersionSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TypeVersionSummary, XmlParseError> {
deserialize_elements::<_, TypeVersionSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"Arn" => {
obj.arn = Some(TypeArnDeserializer::deserialize("Arn", stack)?);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"IsDefaultVersion" => {
obj.is_default_version = Some(IsDefaultVersionDeserializer::deserialize(
"IsDefaultVersion",
stack,
)?);
}
"TimeCreated" => {
obj.time_created =
Some(TimestampDeserializer::deserialize("TimeCreated", stack)?);
}
"Type" => {
obj.type_ = Some(RegistryTypeDeserializer::deserialize("Type", stack)?);
}
"TypeName" => {
obj.type_name = Some(TypeNameDeserializer::deserialize("TypeName", stack)?);
}
"VersionId" => {
obj.version_id =
Some(TypeVersionIdDeserializer::deserialize("VersionId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateStackInput {
pub capabilities: Option<Vec<String>>,
pub client_request_token: Option<String>,
pub notification_ar_ns: Option<Vec<String>>,
pub parameters: Option<Vec<Parameter>>,
pub resource_types: Option<Vec<String>>,
pub role_arn: Option<String>,
pub rollback_configuration: Option<RollbackConfiguration>,
pub stack_name: String,
pub stack_policy_body: Option<String>,
pub stack_policy_during_update_body: Option<String>,
pub stack_policy_during_update_url: Option<String>,
pub stack_policy_url: Option<String>,
pub tags: Option<Vec<Tag>>,
pub template_body: Option<String>,
pub template_url: Option<String>,
pub use_previous_template: Option<bool>,
}
struct UpdateStackInputSerializer;
impl UpdateStackInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateStackInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.capabilities {
CapabilitiesSerializer::serialize(
params,
&format!("{}{}", prefix, "Capabilities"),
field_value,
);
}
if let Some(ref field_value) = obj.client_request_token {
params.put(&format!("{}{}", prefix, "ClientRequestToken"), &field_value);
}
if let Some(ref field_value) = obj.notification_ar_ns {
NotificationARNsSerializer::serialize(
params,
&format!("{}{}", prefix, "NotificationARNs"),
field_value,
);
}
if let Some(ref field_value) = obj.parameters {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameters"),
field_value,
);
}
if let Some(ref field_value) = obj.resource_types {
ResourceTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "ResourceTypes"),
field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
if let Some(ref field_value) = obj.rollback_configuration {
RollbackConfigurationSerializer::serialize(
params,
&format!("{}{}", prefix, "RollbackConfiguration"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
if let Some(ref field_value) = obj.stack_policy_body {
params.put(&format!("{}{}", prefix, "StackPolicyBody"), &field_value);
}
if let Some(ref field_value) = obj.stack_policy_during_update_body {
params.put(
&format!("{}{}", prefix, "StackPolicyDuringUpdateBody"),
&field_value,
);
}
if let Some(ref field_value) = obj.stack_policy_during_update_url {
params.put(
&format!("{}{}", prefix, "StackPolicyDuringUpdateURL"),
&field_value,
);
}
if let Some(ref field_value) = obj.stack_policy_url {
params.put(&format!("{}{}", prefix, "StackPolicyURL"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
if let Some(ref field_value) = obj.use_previous_template {
params.put(
&format!("{}{}", prefix, "UsePreviousTemplate"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateStackInstancesInput {
pub accounts: Option<Vec<String>>,
pub deployment_targets: Option<DeploymentTargets>,
pub operation_id: Option<String>,
pub operation_preferences: Option<StackSetOperationPreferences>,
pub parameter_overrides: Option<Vec<Parameter>>,
pub regions: Vec<String>,
pub stack_set_name: String,
}
struct UpdateStackInstancesInputSerializer;
impl UpdateStackInstancesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateStackInstancesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.accounts {
AccountListSerializer::serialize(
params,
&format!("{}{}", prefix, "Accounts"),
field_value,
);
}
if let Some(ref field_value) = obj.deployment_targets {
DeploymentTargetsSerializer::serialize(
params,
&format!("{}{}", prefix, "DeploymentTargets"),
field_value,
);
}
if let Some(ref field_value) = obj.operation_id {
params.put(&format!("{}{}", prefix, "OperationId"), &field_value);
}
if let Some(ref field_value) = obj.operation_preferences {
StackSetOperationPreferencesSerializer::serialize(
params,
&format!("{}{}", prefix, "OperationPreferences"),
field_value,
);
}
if let Some(ref field_value) = obj.parameter_overrides {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "ParameterOverrides"),
field_value,
);
}
RegionListSerializer::serialize(params, &format!("{}{}", prefix, "Regions"), &obj.regions);
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateStackInstancesOutput {
pub operation_id: Option<String>,
}
#[allow(dead_code)]
struct UpdateStackInstancesOutputDeserializer;
impl UpdateStackInstancesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateStackInstancesOutput, XmlParseError> {
deserialize_elements::<_, UpdateStackInstancesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateStackOutput {
pub stack_id: Option<String>,
}
#[allow(dead_code)]
struct UpdateStackOutputDeserializer;
impl UpdateStackOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateStackOutput, XmlParseError> {
deserialize_elements::<_, UpdateStackOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateStackSetInput {
pub accounts: Option<Vec<String>>,
pub administration_role_arn: Option<String>,
pub auto_deployment: Option<AutoDeployment>,
pub capabilities: Option<Vec<String>>,
pub deployment_targets: Option<DeploymentTargets>,
pub description: Option<String>,
pub execution_role_name: Option<String>,
pub operation_id: Option<String>,
pub operation_preferences: Option<StackSetOperationPreferences>,
pub parameters: Option<Vec<Parameter>>,
pub permission_model: Option<String>,
pub regions: Option<Vec<String>>,
pub stack_set_name: String,
pub tags: Option<Vec<Tag>>,
pub template_body: Option<String>,
pub template_url: Option<String>,
pub use_previous_template: Option<bool>,
}
struct UpdateStackSetInputSerializer;
impl UpdateStackSetInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateStackSetInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.accounts {
AccountListSerializer::serialize(
params,
&format!("{}{}", prefix, "Accounts"),
field_value,
);
}
if let Some(ref field_value) = obj.administration_role_arn {
params.put(
&format!("{}{}", prefix, "AdministrationRoleARN"),
&field_value,
);
}
if let Some(ref field_value) = obj.auto_deployment {
AutoDeploymentSerializer::serialize(
params,
&format!("{}{}", prefix, "AutoDeployment"),
field_value,
);
}
if let Some(ref field_value) = obj.capabilities {
CapabilitiesSerializer::serialize(
params,
&format!("{}{}", prefix, "Capabilities"),
field_value,
);
}
if let Some(ref field_value) = obj.deployment_targets {
DeploymentTargetsSerializer::serialize(
params,
&format!("{}{}", prefix, "DeploymentTargets"),
field_value,
);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.execution_role_name {
params.put(&format!("{}{}", prefix, "ExecutionRoleName"), &field_value);
}
if let Some(ref field_value) = obj.operation_id {
params.put(&format!("{}{}", prefix, "OperationId"), &field_value);
}
if let Some(ref field_value) = obj.operation_preferences {
StackSetOperationPreferencesSerializer::serialize(
params,
&format!("{}{}", prefix, "OperationPreferences"),
field_value,
);
}
if let Some(ref field_value) = obj.parameters {
ParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameters"),
field_value,
);
}
if let Some(ref field_value) = obj.permission_model {
params.put(&format!("{}{}", prefix, "PermissionModel"), &field_value);
}
if let Some(ref field_value) = obj.regions {
RegionListSerializer::serialize(
params,
&format!("{}{}", prefix, "Regions"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "StackSetName"),
&obj.stack_set_name,
);
if let Some(ref field_value) = obj.tags {
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
if let Some(ref field_value) = obj.use_previous_template {
params.put(
&format!("{}{}", prefix, "UsePreviousTemplate"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateStackSetOutput {
pub operation_id: Option<String>,
}
#[allow(dead_code)]
struct UpdateStackSetOutputDeserializer;
impl UpdateStackSetOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateStackSetOutput, XmlParseError> {
deserialize_elements::<_, UpdateStackSetOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"OperationId" => {
obj.operation_id = Some(ClientRequestTokenDeserializer::deserialize(
"OperationId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTerminationProtectionInput {
pub enable_termination_protection: bool,
pub stack_name: String,
}
struct UpdateTerminationProtectionInputSerializer;
impl UpdateTerminationProtectionInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateTerminationProtectionInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "EnableTerminationProtection"),
&obj.enable_termination_protection,
);
params.put(&format!("{}{}", prefix, "StackName"), &obj.stack_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateTerminationProtectionOutput {
pub stack_id: Option<String>,
}
#[allow(dead_code)]
struct UpdateTerminationProtectionOutputDeserializer;
impl UpdateTerminationProtectionOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateTerminationProtectionOutput, XmlParseError> {
deserialize_elements::<_, UpdateTerminationProtectionOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StackId" => {
obj.stack_id = Some(StackIdDeserializer::deserialize("StackId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct UrlDeserializer;
impl UrlDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct UsePreviousValueDeserializer;
impl UsePreviousValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ValidateTemplateInput {
pub template_body: Option<String>,
pub template_url: Option<String>,
}
struct ValidateTemplateInputSerializer;
impl ValidateTemplateInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ValidateTemplateInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.template_body {
params.put(&format!("{}{}", prefix, "TemplateBody"), &field_value);
}
if let Some(ref field_value) = obj.template_url {
params.put(&format!("{}{}", prefix, "TemplateURL"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ValidateTemplateOutput {
pub capabilities: Option<Vec<String>>,
pub capabilities_reason: Option<String>,
pub declared_transforms: Option<Vec<String>>,
pub description: Option<String>,
pub parameters: Option<Vec<TemplateParameter>>,
}
#[allow(dead_code)]
struct ValidateTemplateOutputDeserializer;
impl ValidateTemplateOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ValidateTemplateOutput, XmlParseError> {
deserialize_elements::<_, ValidateTemplateOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Capabilities" => {
obj.capabilities.get_or_insert(vec![]).extend(
CapabilitiesDeserializer::deserialize("Capabilities", stack)?,
);
}
"CapabilitiesReason" => {
obj.capabilities_reason = Some(CapabilitiesReasonDeserializer::deserialize(
"CapabilitiesReason",
stack,
)?);
}
"DeclaredTransforms" => {
obj.declared_transforms.get_or_insert(vec![]).extend(
TransformsListDeserializer::deserialize("DeclaredTransforms", stack)?,
);
}
"Description" => {
obj.description =
Some(DescriptionDeserializer::deserialize("Description", stack)?);
}
"Parameters" => {
obj.parameters.get_or_insert(vec![]).extend(
TemplateParametersDeserializer::deserialize("Parameters", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ValueDeserializer;
impl ValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct VersionDeserializer;
impl VersionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct VisibilityDeserializer;
impl VisibilityDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Debug, PartialEq)]
pub enum CancelUpdateStackError {
TokenAlreadyExists(String),
}
impl CancelUpdateStackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelUpdateStackError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"TokenAlreadyExistsException" => {
return RusotoError::Service(CancelUpdateStackError::TokenAlreadyExists(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CancelUpdateStackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelUpdateStackError::TokenAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelUpdateStackError {}
#[derive(Debug, PartialEq)]
pub enum ContinueUpdateRollbackError {
TokenAlreadyExists(String),
}
impl ContinueUpdateRollbackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ContinueUpdateRollbackError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"TokenAlreadyExistsException" => {
return RusotoError::Service(
ContinueUpdateRollbackError::TokenAlreadyExists(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ContinueUpdateRollbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ContinueUpdateRollbackError::TokenAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ContinueUpdateRollbackError {}
#[derive(Debug, PartialEq)]
pub enum CreateChangeSetError {
AlreadyExists(String),
InsufficientCapabilities(String),
LimitExceeded(String),
}
impl CreateChangeSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateChangeSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AlreadyExistsException" => {
return RusotoError::Service(CreateChangeSetError::AlreadyExists(
parsed_error.message,
))
}
"InsufficientCapabilitiesException" => {
return RusotoError::Service(
CreateChangeSetError::InsufficientCapabilities(parsed_error.message),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateChangeSetError::LimitExceeded(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateChangeSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateChangeSetError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateChangeSetError::InsufficientCapabilities(ref cause) => write!(f, "{}", cause),
CreateChangeSetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateChangeSetError {}
#[derive(Debug, PartialEq)]
pub enum CreateStackError {
AlreadyExists(String),
InsufficientCapabilities(String),
LimitExceeded(String),
TokenAlreadyExists(String),
}
impl CreateStackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateStackError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AlreadyExistsException" => {
return RusotoError::Service(CreateStackError::AlreadyExists(
parsed_error.message,
))
}
"InsufficientCapabilitiesException" => {
return RusotoError::Service(CreateStackError::InsufficientCapabilities(
parsed_error.message,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateStackError::LimitExceeded(
parsed_error.message,
))
}
"TokenAlreadyExistsException" => {
return RusotoError::Service(CreateStackError::TokenAlreadyExists(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateStackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStackError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateStackError::InsufficientCapabilities(ref cause) => write!(f, "{}", cause),
CreateStackError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateStackError::TokenAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateStackError {}
#[derive(Debug, PartialEq)]
pub enum CreateStackInstancesError {
InvalidOperation(String),
LimitExceeded(String),
OperationIdAlreadyExists(String),
OperationInProgress(String),
StackSetNotFound(String),
StaleRequest(String),
}
impl CreateStackInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateStackInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidOperationException" => {
return RusotoError::Service(CreateStackInstancesError::InvalidOperation(
parsed_error.message,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateStackInstancesError::LimitExceeded(
parsed_error.message,
))
}
"OperationIdAlreadyExistsException" => {
return RusotoError::Service(
CreateStackInstancesError::OperationIdAlreadyExists(
parsed_error.message,
),
)
}
"OperationInProgressException" => {
return RusotoError::Service(
CreateStackInstancesError::OperationInProgress(parsed_error.message),
)
}
"StackSetNotFoundException" => {
return RusotoError::Service(CreateStackInstancesError::StackSetNotFound(
parsed_error.message,
))
}
"StaleRequestException" => {
return RusotoError::Service(CreateStackInstancesError::StaleRequest(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateStackInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStackInstancesError::InvalidOperation(ref cause) => write!(f, "{}", cause),
CreateStackInstancesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateStackInstancesError::OperationIdAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateStackInstancesError::OperationInProgress(ref cause) => write!(f, "{}", cause),
CreateStackInstancesError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
CreateStackInstancesError::StaleRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateStackInstancesError {}
#[derive(Debug, PartialEq)]
pub enum CreateStackSetError {
CreatedButModified(String),
LimitExceeded(String),
NameAlreadyExists(String),
}
impl CreateStackSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateStackSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CreatedButModifiedException" => {
return RusotoError::Service(CreateStackSetError::CreatedButModified(
parsed_error.message,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateStackSetError::LimitExceeded(
parsed_error.message,
))
}
"NameAlreadyExistsException" => {
return RusotoError::Service(CreateStackSetError::NameAlreadyExists(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateStackSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStackSetError::CreatedButModified(ref cause) => write!(f, "{}", cause),
CreateStackSetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateStackSetError::NameAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateStackSetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteChangeSetError {
InvalidChangeSetStatus(String),
}
impl DeleteChangeSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteChangeSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidChangeSetStatus" => {
return RusotoError::Service(DeleteChangeSetError::InvalidChangeSetStatus(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteChangeSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteChangeSetError::InvalidChangeSetStatus(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteChangeSetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteStackError {
TokenAlreadyExists(String),
}
impl DeleteStackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteStackError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"TokenAlreadyExistsException" => {
return RusotoError::Service(DeleteStackError::TokenAlreadyExists(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteStackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteStackError::TokenAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteStackError {}
#[derive(Debug, PartialEq)]
pub enum DeleteStackInstancesError {
InvalidOperation(String),
OperationIdAlreadyExists(String),
OperationInProgress(String),
StackSetNotFound(String),
StaleRequest(String),
}
impl DeleteStackInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteStackInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidOperationException" => {
return RusotoError::Service(DeleteStackInstancesError::InvalidOperation(
parsed_error.message,
))
}
"OperationIdAlreadyExistsException" => {
return RusotoError::Service(
DeleteStackInstancesError::OperationIdAlreadyExists(
parsed_error.message,
),
)
}
"OperationInProgressException" => {
return RusotoError::Service(
DeleteStackInstancesError::OperationInProgress(parsed_error.message),
)
}
"StackSetNotFoundException" => {
return RusotoError::Service(DeleteStackInstancesError::StackSetNotFound(
parsed_error.message,
))
}
"StaleRequestException" => {
return RusotoError::Service(DeleteStackInstancesError::StaleRequest(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteStackInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteStackInstancesError::InvalidOperation(ref cause) => write!(f, "{}", cause),
DeleteStackInstancesError::OperationIdAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
DeleteStackInstancesError::OperationInProgress(ref cause) => write!(f, "{}", cause),
DeleteStackInstancesError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
DeleteStackInstancesError::StaleRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteStackInstancesError {}
#[derive(Debug, PartialEq)]
pub enum DeleteStackSetError {
OperationInProgress(String),
StackSetNotEmpty(String),
}
impl DeleteStackSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteStackSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"OperationInProgressException" => {
return RusotoError::Service(DeleteStackSetError::OperationInProgress(
parsed_error.message,
))
}
"StackSetNotEmptyException" => {
return RusotoError::Service(DeleteStackSetError::StackSetNotEmpty(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteStackSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteStackSetError::OperationInProgress(ref cause) => write!(f, "{}", cause),
DeleteStackSetError::StackSetNotEmpty(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteStackSetError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterTypeError {
CFNRegistry(String),
TypeNotFound(String),
}
impl DeregisterTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterTypeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(DeregisterTypeError::CFNRegistry(
parsed_error.message,
))
}
"TypeNotFoundException" => {
return RusotoError::Service(DeregisterTypeError::TypeNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeregisterTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterTypeError::CFNRegistry(ref cause) => write!(f, "{}", cause),
DeregisterTypeError::TypeNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeregisterTypeError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountLimitsError {}
impl DescribeAccountLimitsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAccountLimitsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAccountLimitsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeAccountLimitsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeChangeSetError {
ChangeSetNotFound(String),
}
impl DescribeChangeSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeChangeSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ChangeSetNotFound" => {
return RusotoError::Service(DescribeChangeSetError::ChangeSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeChangeSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeChangeSetError::ChangeSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeChangeSetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackDriftDetectionStatusError {}
impl DescribeStackDriftDetectionStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeStackDriftDetectionStatusError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackDriftDetectionStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStackDriftDetectionStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackEventsError {}
impl DescribeStackEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStackEventsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStackEventsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackInstanceError {
StackInstanceNotFound(String),
StackSetNotFound(String),
}
impl DescribeStackInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStackInstanceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"StackInstanceNotFoundException" => {
return RusotoError::Service(
DescribeStackInstanceError::StackInstanceNotFound(parsed_error.message),
)
}
"StackSetNotFoundException" => {
return RusotoError::Service(DescribeStackInstanceError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeStackInstanceError::StackInstanceNotFound(ref cause) => write!(f, "{}", cause),
DescribeStackInstanceError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeStackInstanceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackResourceError {}
impl DescribeStackResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStackResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStackResourceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackResourceDriftsError {}
impl DescribeStackResourceDriftsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeStackResourceDriftsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackResourceDriftsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStackResourceDriftsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackResourcesError {}
impl DescribeStackResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStackResourcesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStackResourcesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackSetError {
StackSetNotFound(String),
}
impl DescribeStackSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStackSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"StackSetNotFoundException" => {
return RusotoError::Service(DescribeStackSetError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeStackSetError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeStackSetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStackSetOperationError {
OperationNotFound(String),
StackSetNotFound(String),
}
impl DescribeStackSetOperationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStackSetOperationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"OperationNotFoundException" => {
return RusotoError::Service(
DescribeStackSetOperationError::OperationNotFound(parsed_error.message),
)
}
"StackSetNotFoundException" => {
return RusotoError::Service(
DescribeStackSetOperationError::StackSetNotFound(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStackSetOperationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeStackSetOperationError::OperationNotFound(ref cause) => write!(f, "{}", cause),
DescribeStackSetOperationError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeStackSetOperationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStacksError {}
impl DescribeStacksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStacksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeStacksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStacksError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTypeError {
CFNRegistry(String),
TypeNotFound(String),
}
impl DescribeTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTypeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(DescribeTypeError::CFNRegistry(
parsed_error.message,
))
}
"TypeNotFoundException" => {
return RusotoError::Service(DescribeTypeError::TypeNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTypeError::CFNRegistry(ref cause) => write!(f, "{}", cause),
DescribeTypeError::TypeNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTypeError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTypeRegistrationError {
CFNRegistry(String),
}
impl DescribeTypeRegistrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTypeRegistrationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(DescribeTypeRegistrationError::CFNRegistry(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeTypeRegistrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTypeRegistrationError::CFNRegistry(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTypeRegistrationError {}
#[derive(Debug, PartialEq)]
pub enum DetectStackDriftError {}
impl DetectStackDriftError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetectStackDriftError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetectStackDriftError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DetectStackDriftError {}
#[derive(Debug, PartialEq)]
pub enum DetectStackResourceDriftError {}
impl DetectStackResourceDriftError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetectStackResourceDriftError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetectStackResourceDriftError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DetectStackResourceDriftError {}
#[derive(Debug, PartialEq)]
pub enum DetectStackSetDriftError {
InvalidOperation(String),
OperationInProgress(String),
StackSetNotFound(String),
}
impl DetectStackSetDriftError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetectStackSetDriftError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidOperationException" => {
return RusotoError::Service(DetectStackSetDriftError::InvalidOperation(
parsed_error.message,
))
}
"OperationInProgressException" => {
return RusotoError::Service(DetectStackSetDriftError::OperationInProgress(
parsed_error.message,
))
}
"StackSetNotFoundException" => {
return RusotoError::Service(DetectStackSetDriftError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DetectStackSetDriftError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetectStackSetDriftError::InvalidOperation(ref cause) => write!(f, "{}", cause),
DetectStackSetDriftError::OperationInProgress(ref cause) => write!(f, "{}", cause),
DetectStackSetDriftError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetectStackSetDriftError {}
#[derive(Debug, PartialEq)]
pub enum EstimateTemplateCostError {}
impl EstimateTemplateCostError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EstimateTemplateCostError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EstimateTemplateCostError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for EstimateTemplateCostError {}
#[derive(Debug, PartialEq)]
pub enum ExecuteChangeSetError {
ChangeSetNotFound(String),
InsufficientCapabilities(String),
InvalidChangeSetStatus(String),
TokenAlreadyExists(String),
}
impl ExecuteChangeSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ExecuteChangeSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ChangeSetNotFound" => {
return RusotoError::Service(ExecuteChangeSetError::ChangeSetNotFound(
parsed_error.message,
))
}
"InsufficientCapabilitiesException" => {
return RusotoError::Service(
ExecuteChangeSetError::InsufficientCapabilities(parsed_error.message),
)
}
"InvalidChangeSetStatus" => {
return RusotoError::Service(ExecuteChangeSetError::InvalidChangeSetStatus(
parsed_error.message,
))
}
"TokenAlreadyExistsException" => {
return RusotoError::Service(ExecuteChangeSetError::TokenAlreadyExists(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ExecuteChangeSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExecuteChangeSetError::ChangeSetNotFound(ref cause) => write!(f, "{}", cause),
ExecuteChangeSetError::InsufficientCapabilities(ref cause) => write!(f, "{}", cause),
ExecuteChangeSetError::InvalidChangeSetStatus(ref cause) => write!(f, "{}", cause),
ExecuteChangeSetError::TokenAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExecuteChangeSetError {}
#[derive(Debug, PartialEq)]
pub enum GetStackPolicyError {}
impl GetStackPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetStackPolicyError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetStackPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for GetStackPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetTemplateError {
ChangeSetNotFound(String),
}
impl GetTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTemplateError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ChangeSetNotFound" => {
return RusotoError::Service(GetTemplateError::ChangeSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTemplateError::ChangeSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetTemplateSummaryError {
StackSetNotFound(String),
}
impl GetTemplateSummaryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTemplateSummaryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"StackSetNotFoundException" => {
return RusotoError::Service(GetTemplateSummaryError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetTemplateSummaryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTemplateSummaryError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTemplateSummaryError {}
#[derive(Debug, PartialEq)]
pub enum ListChangeSetsError {}
impl ListChangeSetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListChangeSetsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListChangeSetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListChangeSetsError {}
#[derive(Debug, PartialEq)]
pub enum ListExportsError {}
impl ListExportsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListExportsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListExportsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListExportsError {}
#[derive(Debug, PartialEq)]
pub enum ListImportsError {}
impl ListImportsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImportsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListImportsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListImportsError {}
#[derive(Debug, PartialEq)]
pub enum ListStackInstancesError {
StackSetNotFound(String),
}
impl ListStackInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListStackInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"StackSetNotFoundException" => {
return RusotoError::Service(ListStackInstancesError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListStackInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListStackInstancesError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListStackInstancesError {}
#[derive(Debug, PartialEq)]
pub enum ListStackResourcesError {}
impl ListStackResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListStackResourcesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListStackResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListStackResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListStackSetOperationResultsError {
OperationNotFound(String),
StackSetNotFound(String),
}
impl ListStackSetOperationResultsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListStackSetOperationResultsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"OperationNotFoundException" => {
return RusotoError::Service(
ListStackSetOperationResultsError::OperationNotFound(
parsed_error.message,
),
)
}
"StackSetNotFoundException" => {
return RusotoError::Service(
ListStackSetOperationResultsError::StackSetNotFound(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListStackSetOperationResultsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListStackSetOperationResultsError::OperationNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListStackSetOperationResultsError::StackSetNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListStackSetOperationResultsError {}
#[derive(Debug, PartialEq)]
pub enum ListStackSetOperationsError {
StackSetNotFound(String),
}
impl ListStackSetOperationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListStackSetOperationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"StackSetNotFoundException" => {
return RusotoError::Service(ListStackSetOperationsError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListStackSetOperationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListStackSetOperationsError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListStackSetOperationsError {}
#[derive(Debug, PartialEq)]
pub enum ListStackSetsError {}
impl ListStackSetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListStackSetsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListStackSetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListStackSetsError {}
#[derive(Debug, PartialEq)]
pub enum ListStacksError {}
impl ListStacksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListStacksError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListStacksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListStacksError {}
#[derive(Debug, PartialEq)]
pub enum ListTypeRegistrationsError {
CFNRegistry(String),
}
impl ListTypeRegistrationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTypeRegistrationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(ListTypeRegistrationsError::CFNRegistry(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListTypeRegistrationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTypeRegistrationsError::CFNRegistry(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTypeRegistrationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTypeVersionsError {
CFNRegistry(String),
}
impl ListTypeVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTypeVersionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(ListTypeVersionsError::CFNRegistry(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListTypeVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTypeVersionsError::CFNRegistry(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTypeVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTypesError {
CFNRegistry(String),
}
impl ListTypesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTypesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(ListTypesError::CFNRegistry(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTypesError::CFNRegistry(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTypesError {}
#[derive(Debug, PartialEq)]
pub enum RecordHandlerProgressError {
InvalidStateTransition(String),
OperationStatusCheckFailed(String),
}
impl RecordHandlerProgressError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RecordHandlerProgressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidStateTransition" => {
return RusotoError::Service(
RecordHandlerProgressError::InvalidStateTransition(
parsed_error.message,
),
)
}
"ConditionalCheckFailed" => {
return RusotoError::Service(
RecordHandlerProgressError::OperationStatusCheckFailed(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RecordHandlerProgressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RecordHandlerProgressError::InvalidStateTransition(ref cause) => write!(f, "{}", cause),
RecordHandlerProgressError::OperationStatusCheckFailed(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RecordHandlerProgressError {}
#[derive(Debug, PartialEq)]
pub enum RegisterTypeError {
CFNRegistry(String),
}
impl RegisterTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterTypeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(RegisterTypeError::CFNRegistry(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RegisterTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterTypeError::CFNRegistry(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterTypeError {}
#[derive(Debug, PartialEq)]
pub enum SetStackPolicyError {}
impl SetStackPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetStackPolicyError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for SetStackPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for SetStackPolicyError {}
#[derive(Debug, PartialEq)]
pub enum SetTypeDefaultVersionError {
CFNRegistry(String),
TypeNotFound(String),
}
impl SetTypeDefaultVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetTypeDefaultVersionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CFNRegistryException" => {
return RusotoError::Service(SetTypeDefaultVersionError::CFNRegistry(
parsed_error.message,
))
}
"TypeNotFoundException" => {
return RusotoError::Service(SetTypeDefaultVersionError::TypeNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for SetTypeDefaultVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetTypeDefaultVersionError::CFNRegistry(ref cause) => write!(f, "{}", cause),
SetTypeDefaultVersionError::TypeNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetTypeDefaultVersionError {}
#[derive(Debug, PartialEq)]
pub enum SignalResourceError {}
impl SignalResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SignalResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for SignalResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for SignalResourceError {}
#[derive(Debug, PartialEq)]
pub enum StopStackSetOperationError {
InvalidOperation(String),
OperationNotFound(String),
StackSetNotFound(String),
}
impl StopStackSetOperationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopStackSetOperationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidOperationException" => {
return RusotoError::Service(StopStackSetOperationError::InvalidOperation(
parsed_error.message,
))
}
"OperationNotFoundException" => {
return RusotoError::Service(StopStackSetOperationError::OperationNotFound(
parsed_error.message,
))
}
"StackSetNotFoundException" => {
return RusotoError::Service(StopStackSetOperationError::StackSetNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for StopStackSetOperationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopStackSetOperationError::InvalidOperation(ref cause) => write!(f, "{}", cause),
StopStackSetOperationError::OperationNotFound(ref cause) => write!(f, "{}", cause),
StopStackSetOperationError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopStackSetOperationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateStackError {
InsufficientCapabilities(String),
TokenAlreadyExists(String),
}
impl UpdateStackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateStackError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InsufficientCapabilitiesException" => {
return RusotoError::Service(UpdateStackError::InsufficientCapabilities(
parsed_error.message,
))
}
"TokenAlreadyExistsException" => {
return RusotoError::Service(UpdateStackError::TokenAlreadyExists(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateStackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateStackError::InsufficientCapabilities(ref cause) => write!(f, "{}", cause),
UpdateStackError::TokenAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateStackError {}
#[derive(Debug, PartialEq)]
pub enum UpdateStackInstancesError {
InvalidOperation(String),
OperationIdAlreadyExists(String),
OperationInProgress(String),
StackInstanceNotFound(String),
StackSetNotFound(String),
StaleRequest(String),
}
impl UpdateStackInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateStackInstancesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidOperationException" => {
return RusotoError::Service(UpdateStackInstancesError::InvalidOperation(
parsed_error.message,
))
}
"OperationIdAlreadyExistsException" => {
return RusotoError::Service(
UpdateStackInstancesError::OperationIdAlreadyExists(
parsed_error.message,
),
)
}
"OperationInProgressException" => {
return RusotoError::Service(
UpdateStackInstancesError::OperationInProgress(parsed_error.message),
)
}
"StackInstanceNotFoundException" => {
return RusotoError::Service(
UpdateStackInstancesError::StackInstanceNotFound(parsed_error.message),
)
}
"StackSetNotFoundException" => {
return RusotoError::Service(UpdateStackInstancesError::StackSetNotFound(
parsed_error.message,
))
}
"StaleRequestException" => {
return RusotoError::Service(UpdateStackInstancesError::StaleRequest(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateStackInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateStackInstancesError::InvalidOperation(ref cause) => write!(f, "{}", cause),
UpdateStackInstancesError::OperationIdAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
UpdateStackInstancesError::OperationInProgress(ref cause) => write!(f, "{}", cause),
UpdateStackInstancesError::StackInstanceNotFound(ref cause) => write!(f, "{}", cause),
UpdateStackInstancesError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
UpdateStackInstancesError::StaleRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateStackInstancesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateStackSetError {
InvalidOperation(String),
OperationIdAlreadyExists(String),
OperationInProgress(String),
StackInstanceNotFound(String),
StackSetNotFound(String),
StaleRequest(String),
}
impl UpdateStackSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateStackSetError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidOperationException" => {
return RusotoError::Service(UpdateStackSetError::InvalidOperation(
parsed_error.message,
))
}
"OperationIdAlreadyExistsException" => {
return RusotoError::Service(UpdateStackSetError::OperationIdAlreadyExists(
parsed_error.message,
))
}
"OperationInProgressException" => {
return RusotoError::Service(UpdateStackSetError::OperationInProgress(
parsed_error.message,
))
}
"StackInstanceNotFoundException" => {
return RusotoError::Service(UpdateStackSetError::StackInstanceNotFound(
parsed_error.message,
))
}
"StackSetNotFoundException" => {
return RusotoError::Service(UpdateStackSetError::StackSetNotFound(
parsed_error.message,
))
}
"StaleRequestException" => {
return RusotoError::Service(UpdateStackSetError::StaleRequest(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateStackSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateStackSetError::InvalidOperation(ref cause) => write!(f, "{}", cause),
UpdateStackSetError::OperationIdAlreadyExists(ref cause) => write!(f, "{}", cause),
UpdateStackSetError::OperationInProgress(ref cause) => write!(f, "{}", cause),
UpdateStackSetError::StackInstanceNotFound(ref cause) => write!(f, "{}", cause),
UpdateStackSetError::StackSetNotFound(ref cause) => write!(f, "{}", cause),
UpdateStackSetError::StaleRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateStackSetError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTerminationProtectionError {}
impl UpdateTerminationProtectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateTerminationProtectionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateTerminationProtectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for UpdateTerminationProtectionError {}
#[derive(Debug, PartialEq)]
pub enum ValidateTemplateError {}
impl ValidateTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ValidateTemplateError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ValidateTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ValidateTemplateError {}
#[async_trait]
pub trait CloudFormation {
async fn cancel_update_stack(
&self,
input: CancelUpdateStackInput,
) -> Result<(), RusotoError<CancelUpdateStackError>>;
async fn continue_update_rollback(
&self,
input: ContinueUpdateRollbackInput,
) -> Result<ContinueUpdateRollbackOutput, RusotoError<ContinueUpdateRollbackError>>;
async fn create_change_set(
&self,
input: CreateChangeSetInput,
) -> Result<CreateChangeSetOutput, RusotoError<CreateChangeSetError>>;
async fn create_stack(
&self,
input: CreateStackInput,
) -> Result<CreateStackOutput, RusotoError<CreateStackError>>;
async fn create_stack_instances(
&self,
input: CreateStackInstancesInput,
) -> Result<CreateStackInstancesOutput, RusotoError<CreateStackInstancesError>>;
async fn create_stack_set(
&self,
input: CreateStackSetInput,
) -> Result<CreateStackSetOutput, RusotoError<CreateStackSetError>>;
async fn delete_change_set(
&self,
input: DeleteChangeSetInput,
) -> Result<DeleteChangeSetOutput, RusotoError<DeleteChangeSetError>>;
async fn delete_stack(
&self,
input: DeleteStackInput,
) -> Result<(), RusotoError<DeleteStackError>>;
async fn delete_stack_instances(
&self,
input: DeleteStackInstancesInput,
) -> Result<DeleteStackInstancesOutput, RusotoError<DeleteStackInstancesError>>;
async fn delete_stack_set(
&self,
input: DeleteStackSetInput,
) -> Result<DeleteStackSetOutput, RusotoError<DeleteStackSetError>>;
async fn deregister_type(
&self,
input: DeregisterTypeInput,
) -> Result<DeregisterTypeOutput, RusotoError<DeregisterTypeError>>;
async fn describe_account_limits(
&self,
input: DescribeAccountLimitsInput,
) -> Result<DescribeAccountLimitsOutput, RusotoError<DescribeAccountLimitsError>>;
async fn describe_change_set(
&self,
input: DescribeChangeSetInput,
) -> Result<DescribeChangeSetOutput, RusotoError<DescribeChangeSetError>>;
async fn describe_stack_drift_detection_status(
&self,
input: DescribeStackDriftDetectionStatusInput,
) -> Result<
DescribeStackDriftDetectionStatusOutput,
RusotoError<DescribeStackDriftDetectionStatusError>,
>;
async fn describe_stack_events(
&self,
input: DescribeStackEventsInput,
) -> Result<DescribeStackEventsOutput, RusotoError<DescribeStackEventsError>>;
async fn describe_stack_instance(
&self,
input: DescribeStackInstanceInput,
) -> Result<DescribeStackInstanceOutput, RusotoError<DescribeStackInstanceError>>;
async fn describe_stack_resource(
&self,
input: DescribeStackResourceInput,
) -> Result<DescribeStackResourceOutput, RusotoError<DescribeStackResourceError>>;
async fn describe_stack_resource_drifts(
&self,
input: DescribeStackResourceDriftsInput,
) -> Result<DescribeStackResourceDriftsOutput, RusotoError<DescribeStackResourceDriftsError>>;
async fn describe_stack_resources(
&self,
input: DescribeStackResourcesInput,
) -> Result<DescribeStackResourcesOutput, RusotoError<DescribeStackResourcesError>>;
async fn describe_stack_set(
&self,
input: DescribeStackSetInput,
) -> Result<DescribeStackSetOutput, RusotoError<DescribeStackSetError>>;
async fn describe_stack_set_operation(
&self,
input: DescribeStackSetOperationInput,
) -> Result<DescribeStackSetOperationOutput, RusotoError<DescribeStackSetOperationError>>;
async fn describe_stacks(
&self,
input: DescribeStacksInput,
) -> Result<DescribeStacksOutput, RusotoError<DescribeStacksError>>;
async fn describe_type(
&self,
input: DescribeTypeInput,
) -> Result<DescribeTypeOutput, RusotoError<DescribeTypeError>>;
async fn describe_type_registration(
&self,
input: DescribeTypeRegistrationInput,
) -> Result<DescribeTypeRegistrationOutput, RusotoError<DescribeTypeRegistrationError>>;
async fn detect_stack_drift(
&self,
input: DetectStackDriftInput,
) -> Result<DetectStackDriftOutput, RusotoError<DetectStackDriftError>>;
async fn detect_stack_resource_drift(
&self,
input: DetectStackResourceDriftInput,
) -> Result<DetectStackResourceDriftOutput, RusotoError<DetectStackResourceDriftError>>;
async fn detect_stack_set_drift(
&self,
input: DetectStackSetDriftInput,
) -> Result<DetectStackSetDriftOutput, RusotoError<DetectStackSetDriftError>>;
async fn estimate_template_cost(
&self,
input: EstimateTemplateCostInput,
) -> Result<EstimateTemplateCostOutput, RusotoError<EstimateTemplateCostError>>;
async fn execute_change_set(
&self,
input: ExecuteChangeSetInput,
) -> Result<ExecuteChangeSetOutput, RusotoError<ExecuteChangeSetError>>;
async fn get_stack_policy(
&self,
input: GetStackPolicyInput,
) -> Result<GetStackPolicyOutput, RusotoError<GetStackPolicyError>>;
async fn get_template(
&self,
input: GetTemplateInput,
) -> Result<GetTemplateOutput, RusotoError<GetTemplateError>>;
async fn get_template_summary(
&self,
input: GetTemplateSummaryInput,
) -> Result<GetTemplateSummaryOutput, RusotoError<GetTemplateSummaryError>>;
async fn list_change_sets(
&self,
input: ListChangeSetsInput,
) -> Result<ListChangeSetsOutput, RusotoError<ListChangeSetsError>>;
async fn list_exports(
&self,
input: ListExportsInput,
) -> Result<ListExportsOutput, RusotoError<ListExportsError>>;
async fn list_imports(
&self,
input: ListImportsInput,
) -> Result<ListImportsOutput, RusotoError<ListImportsError>>;
async fn list_stack_instances(
&self,
input: ListStackInstancesInput,
) -> Result<ListStackInstancesOutput, RusotoError<ListStackInstancesError>>;
async fn list_stack_resources(
&self,
input: ListStackResourcesInput,
) -> Result<ListStackResourcesOutput, RusotoError<ListStackResourcesError>>;
async fn list_stack_set_operation_results(
&self,
input: ListStackSetOperationResultsInput,
) -> Result<ListStackSetOperationResultsOutput, RusotoError<ListStackSetOperationResultsError>>;
async fn list_stack_set_operations(
&self,
input: ListStackSetOperationsInput,
) -> Result<ListStackSetOperationsOutput, RusotoError<ListStackSetOperationsError>>;
async fn list_stack_sets(
&self,
input: ListStackSetsInput,
) -> Result<ListStackSetsOutput, RusotoError<ListStackSetsError>>;
async fn list_stacks(
&self,
input: ListStacksInput,
) -> Result<ListStacksOutput, RusotoError<ListStacksError>>;
async fn list_type_registrations(
&self,
input: ListTypeRegistrationsInput,
) -> Result<ListTypeRegistrationsOutput, RusotoError<ListTypeRegistrationsError>>;
async fn list_type_versions(
&self,
input: ListTypeVersionsInput,
) -> Result<ListTypeVersionsOutput, RusotoError<ListTypeVersionsError>>;
async fn list_types(
&self,
input: ListTypesInput,
) -> Result<ListTypesOutput, RusotoError<ListTypesError>>;
async fn record_handler_progress(
&self,
input: RecordHandlerProgressInput,
) -> Result<RecordHandlerProgressOutput, RusotoError<RecordHandlerProgressError>>;
async fn register_type(
&self,
input: RegisterTypeInput,
) -> Result<RegisterTypeOutput, RusotoError<RegisterTypeError>>;
async fn set_stack_policy(
&self,
input: SetStackPolicyInput,
) -> Result<(), RusotoError<SetStackPolicyError>>;
async fn set_type_default_version(
&self,
input: SetTypeDefaultVersionInput,
) -> Result<SetTypeDefaultVersionOutput, RusotoError<SetTypeDefaultVersionError>>;
async fn signal_resource(
&self,
input: SignalResourceInput,
) -> Result<(), RusotoError<SignalResourceError>>;
async fn stop_stack_set_operation(
&self,
input: StopStackSetOperationInput,
) -> Result<StopStackSetOperationOutput, RusotoError<StopStackSetOperationError>>;
async fn update_stack(
&self,
input: UpdateStackInput,
) -> Result<UpdateStackOutput, RusotoError<UpdateStackError>>;
async fn update_stack_instances(
&self,
input: UpdateStackInstancesInput,
) -> Result<UpdateStackInstancesOutput, RusotoError<UpdateStackInstancesError>>;
async fn update_stack_set(
&self,
input: UpdateStackSetInput,
) -> Result<UpdateStackSetOutput, RusotoError<UpdateStackSetError>>;
async fn update_termination_protection(
&self,
input: UpdateTerminationProtectionInput,
) -> Result<UpdateTerminationProtectionOutput, RusotoError<UpdateTerminationProtectionError>>;
async fn validate_template(
&self,
input: ValidateTemplateInput,
) -> Result<ValidateTemplateOutput, RusotoError<ValidateTemplateError>>;
}
#[derive(Clone)]
pub struct CloudFormationClient {
client: Client,
region: region::Region,
}
impl CloudFormationClient {
pub fn new(region: region::Region) -> CloudFormationClient {
CloudFormationClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudFormationClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CloudFormationClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CloudFormationClient {
CloudFormationClient { client, region }
}
}
#[async_trait]
impl CloudFormation for CloudFormationClient {
async fn cancel_update_stack(
&self,
input: CancelUpdateStackInput,
) -> Result<(), RusotoError<CancelUpdateStackError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("CancelUpdateStack");
let mut params = params;
CancelUpdateStackInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CancelUpdateStackError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn continue_update_rollback(
&self,
input: ContinueUpdateRollbackInput,
) -> Result<ContinueUpdateRollbackOutput, RusotoError<ContinueUpdateRollbackError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ContinueUpdateRollback");
let mut params = params;
ContinueUpdateRollbackInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ContinueUpdateRollbackError::from_response)
.await?;
let result = ContinueUpdateRollbackOutput::default();
drop(response);
Ok(result)
}
async fn create_change_set(
&self,
input: CreateChangeSetInput,
) -> Result<CreateChangeSetOutput, RusotoError<CreateChangeSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("CreateChangeSet");
let mut params = params;
CreateChangeSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateChangeSetError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
CreateChangeSetOutputDeserializer::deserialize("CreateChangeSetResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_stack(
&self,
input: CreateStackInput,
) -> Result<CreateStackOutput, RusotoError<CreateStackError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("CreateStack");
let mut params = params;
CreateStackInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateStackError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateStackOutputDeserializer::deserialize("CreateStackResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_stack_instances(
&self,
input: CreateStackInstancesInput,
) -> Result<CreateStackInstancesOutput, RusotoError<CreateStackInstancesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("CreateStackInstances");
let mut params = params;
CreateStackInstancesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateStackInstancesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateStackInstancesOutputDeserializer::deserialize(
"CreateStackInstancesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_stack_set(
&self,
input: CreateStackSetInput,
) -> Result<CreateStackSetOutput, RusotoError<CreateStackSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("CreateStackSet");
let mut params = params;
CreateStackSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateStackSetError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
CreateStackSetOutputDeserializer::deserialize("CreateStackSetResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_change_set(
&self,
input: DeleteChangeSetInput,
) -> Result<DeleteChangeSetOutput, RusotoError<DeleteChangeSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DeleteChangeSet");
let mut params = params;
DeleteChangeSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteChangeSetError::from_response)
.await?;
let result = DeleteChangeSetOutput::default();
drop(response);
Ok(result)
}
async fn delete_stack(
&self,
input: DeleteStackInput,
) -> Result<(), RusotoError<DeleteStackError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DeleteStack");
let mut params = params;
DeleteStackInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteStackError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_stack_instances(
&self,
input: DeleteStackInstancesInput,
) -> Result<DeleteStackInstancesOutput, RusotoError<DeleteStackInstancesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DeleteStackInstances");
let mut params = params;
DeleteStackInstancesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteStackInstancesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DeleteStackInstancesOutputDeserializer::deserialize(
"DeleteStackInstancesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_stack_set(
&self,
input: DeleteStackSetInput,
) -> Result<DeleteStackSetOutput, RusotoError<DeleteStackSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DeleteStackSet");
let mut params = params;
DeleteStackSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteStackSetError::from_response)
.await?;
let result = DeleteStackSetOutput::default();
drop(response);
Ok(result)
}
async fn deregister_type(
&self,
input: DeregisterTypeInput,
) -> Result<DeregisterTypeOutput, RusotoError<DeregisterTypeError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DeregisterType");
let mut params = params;
DeregisterTypeInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeregisterTypeError::from_response)
.await?;
let result = DeregisterTypeOutput::default();
drop(response);
Ok(result)
}
async fn describe_account_limits(
&self,
input: DescribeAccountLimitsInput,
) -> Result<DescribeAccountLimitsOutput, RusotoError<DescribeAccountLimitsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeAccountLimits");
let mut params = params;
DescribeAccountLimitsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAccountLimitsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeAccountLimitsOutputDeserializer::deserialize(
"DescribeAccountLimitsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_change_set(
&self,
input: DescribeChangeSetInput,
) -> Result<DescribeChangeSetOutput, RusotoError<DescribeChangeSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeChangeSet");
let mut params = params;
DescribeChangeSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeChangeSetError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DescribeChangeSetOutputDeserializer::deserialize("DescribeChangeSetResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_drift_detection_status(
&self,
input: DescribeStackDriftDetectionStatusInput,
) -> Result<
DescribeStackDriftDetectionStatusOutput,
RusotoError<DescribeStackDriftDetectionStatusError>,
> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackDriftDetectionStatus");
let mut params = params;
DescribeStackDriftDetectionStatusInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
DescribeStackDriftDetectionStatusError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackDriftDetectionStatusOutputDeserializer::deserialize(
"DescribeStackDriftDetectionStatusResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_events(
&self,
input: DescribeStackEventsInput,
) -> Result<DescribeStackEventsOutput, RusotoError<DescribeStackEventsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackEvents");
let mut params = params;
DescribeStackEventsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackEventsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackEventsOutputDeserializer::deserialize(
"DescribeStackEventsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_instance(
&self,
input: DescribeStackInstanceInput,
) -> Result<DescribeStackInstanceOutput, RusotoError<DescribeStackInstanceError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackInstance");
let mut params = params;
DescribeStackInstanceInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackInstanceError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackInstanceOutputDeserializer::deserialize(
"DescribeStackInstanceResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_resource(
&self,
input: DescribeStackResourceInput,
) -> Result<DescribeStackResourceOutput, RusotoError<DescribeStackResourceError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackResource");
let mut params = params;
DescribeStackResourceInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackResourceError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackResourceOutputDeserializer::deserialize(
"DescribeStackResourceResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_resource_drifts(
&self,
input: DescribeStackResourceDriftsInput,
) -> Result<DescribeStackResourceDriftsOutput, RusotoError<DescribeStackResourceDriftsError>>
{
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackResourceDrifts");
let mut params = params;
DescribeStackResourceDriftsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackResourceDriftsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackResourceDriftsOutputDeserializer::deserialize(
"DescribeStackResourceDriftsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_resources(
&self,
input: DescribeStackResourcesInput,
) -> Result<DescribeStackResourcesOutput, RusotoError<DescribeStackResourcesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackResources");
let mut params = params;
DescribeStackResourcesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackResourcesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackResourcesOutputDeserializer::deserialize(
"DescribeStackResourcesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_set(
&self,
input: DescribeStackSetInput,
) -> Result<DescribeStackSetOutput, RusotoError<DescribeStackSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackSet");
let mut params = params;
DescribeStackSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackSetError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DescribeStackSetOutputDeserializer::deserialize("DescribeStackSetResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stack_set_operation(
&self,
input: DescribeStackSetOperationInput,
) -> Result<DescribeStackSetOperationOutput, RusotoError<DescribeStackSetOperationError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStackSetOperation");
let mut params = params;
DescribeStackSetOperationInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStackSetOperationError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeStackSetOperationOutputDeserializer::deserialize(
"DescribeStackSetOperationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_stacks(
&self,
input: DescribeStacksInput,
) -> Result<DescribeStacksOutput, RusotoError<DescribeStacksError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeStacks");
let mut params = params;
DescribeStacksInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeStacksError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DescribeStacksOutputDeserializer::deserialize("DescribeStacksResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_type(
&self,
input: DescribeTypeInput,
) -> Result<DescribeTypeOutput, RusotoError<DescribeTypeError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeType");
let mut params = params;
DescribeTypeInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeTypeError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeTypeOutputDeserializer::deserialize("DescribeTypeResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_type_registration(
&self,
input: DescribeTypeRegistrationInput,
) -> Result<DescribeTypeRegistrationOutput, RusotoError<DescribeTypeRegistrationError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DescribeTypeRegistration");
let mut params = params;
DescribeTypeRegistrationInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeTypeRegistrationError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeTypeRegistrationOutputDeserializer::deserialize(
"DescribeTypeRegistrationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn detect_stack_drift(
&self,
input: DetectStackDriftInput,
) -> Result<DetectStackDriftOutput, RusotoError<DetectStackDriftError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DetectStackDrift");
let mut params = params;
DetectStackDriftInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DetectStackDriftError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DetectStackDriftOutputDeserializer::deserialize("DetectStackDriftResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn detect_stack_resource_drift(
&self,
input: DetectStackResourceDriftInput,
) -> Result<DetectStackResourceDriftOutput, RusotoError<DetectStackResourceDriftError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DetectStackResourceDrift");
let mut params = params;
DetectStackResourceDriftInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DetectStackResourceDriftError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DetectStackResourceDriftOutputDeserializer::deserialize(
"DetectStackResourceDriftResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn detect_stack_set_drift(
&self,
input: DetectStackSetDriftInput,
) -> Result<DetectStackSetDriftOutput, RusotoError<DetectStackSetDriftError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("DetectStackSetDrift");
let mut params = params;
DetectStackSetDriftInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DetectStackSetDriftError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DetectStackSetDriftOutputDeserializer::deserialize(
"DetectStackSetDriftResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn estimate_template_cost(
&self,
input: EstimateTemplateCostInput,
) -> Result<EstimateTemplateCostOutput, RusotoError<EstimateTemplateCostError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("EstimateTemplateCost");
let mut params = params;
EstimateTemplateCostInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, EstimateTemplateCostError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = EstimateTemplateCostOutputDeserializer::deserialize(
"EstimateTemplateCostResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn execute_change_set(
&self,
input: ExecuteChangeSetInput,
) -> Result<ExecuteChangeSetOutput, RusotoError<ExecuteChangeSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ExecuteChangeSet");
let mut params = params;
ExecuteChangeSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ExecuteChangeSetError::from_response)
.await?;
let result = ExecuteChangeSetOutput::default();
drop(response);
Ok(result)
}
async fn get_stack_policy(
&self,
input: GetStackPolicyInput,
) -> Result<GetStackPolicyOutput, RusotoError<GetStackPolicyError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("GetStackPolicy");
let mut params = params;
GetStackPolicyInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetStackPolicyError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
GetStackPolicyOutputDeserializer::deserialize("GetStackPolicyResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_template(
&self,
input: GetTemplateInput,
) -> Result<GetTemplateOutput, RusotoError<GetTemplateError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("GetTemplate");
let mut params = params;
GetTemplateInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetTemplateError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = GetTemplateOutputDeserializer::deserialize("GetTemplateResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_template_summary(
&self,
input: GetTemplateSummaryInput,
) -> Result<GetTemplateSummaryOutput, RusotoError<GetTemplateSummaryError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("GetTemplateSummary");
let mut params = params;
GetTemplateSummaryInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetTemplateSummaryError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = GetTemplateSummaryOutputDeserializer::deserialize(
"GetTemplateSummaryResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_change_sets(
&self,
input: ListChangeSetsInput,
) -> Result<ListChangeSetsOutput, RusotoError<ListChangeSetsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListChangeSets");
let mut params = params;
ListChangeSetsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListChangeSetsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
ListChangeSetsOutputDeserializer::deserialize("ListChangeSetsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_exports(
&self,
input: ListExportsInput,
) -> Result<ListExportsOutput, RusotoError<ListExportsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListExports");
let mut params = params;
ListExportsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListExportsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListExportsOutputDeserializer::deserialize("ListExportsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_imports(
&self,
input: ListImportsInput,
) -> Result<ListImportsOutput, RusotoError<ListImportsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListImports");
let mut params = params;
ListImportsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListImportsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListImportsOutputDeserializer::deserialize("ListImportsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_stack_instances(
&self,
input: ListStackInstancesInput,
) -> Result<ListStackInstancesOutput, RusotoError<ListStackInstancesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListStackInstances");
let mut params = params;
ListStackInstancesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListStackInstancesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListStackInstancesOutputDeserializer::deserialize(
"ListStackInstancesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_stack_resources(
&self,
input: ListStackResourcesInput,
) -> Result<ListStackResourcesOutput, RusotoError<ListStackResourcesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListStackResources");
let mut params = params;
ListStackResourcesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListStackResourcesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListStackResourcesOutputDeserializer::deserialize(
"ListStackResourcesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_stack_set_operation_results(
&self,
input: ListStackSetOperationResultsInput,
) -> Result<ListStackSetOperationResultsOutput, RusotoError<ListStackSetOperationResultsError>>
{
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListStackSetOperationResults");
let mut params = params;
ListStackSetOperationResultsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListStackSetOperationResultsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListStackSetOperationResultsOutputDeserializer::deserialize(
"ListStackSetOperationResultsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_stack_set_operations(
&self,
input: ListStackSetOperationsInput,
) -> Result<ListStackSetOperationsOutput, RusotoError<ListStackSetOperationsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListStackSetOperations");
let mut params = params;
ListStackSetOperationsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListStackSetOperationsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListStackSetOperationsOutputDeserializer::deserialize(
"ListStackSetOperationsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_stack_sets(
&self,
input: ListStackSetsInput,
) -> Result<ListStackSetsOutput, RusotoError<ListStackSetsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListStackSets");
let mut params = params;
ListStackSetsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListStackSetsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
ListStackSetsOutputDeserializer::deserialize("ListStackSetsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_stacks(
&self,
input: ListStacksInput,
) -> Result<ListStacksOutput, RusotoError<ListStacksError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListStacks");
let mut params = params;
ListStacksInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListStacksError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListStacksOutputDeserializer::deserialize("ListStacksResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_type_registrations(
&self,
input: ListTypeRegistrationsInput,
) -> Result<ListTypeRegistrationsOutput, RusotoError<ListTypeRegistrationsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListTypeRegistrations");
let mut params = params;
ListTypeRegistrationsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListTypeRegistrationsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListTypeRegistrationsOutputDeserializer::deserialize(
"ListTypeRegistrationsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_type_versions(
&self,
input: ListTypeVersionsInput,
) -> Result<ListTypeVersionsOutput, RusotoError<ListTypeVersionsError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListTypeVersions");
let mut params = params;
ListTypeVersionsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListTypeVersionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
ListTypeVersionsOutputDeserializer::deserialize("ListTypeVersionsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_types(
&self,
input: ListTypesInput,
) -> Result<ListTypesOutput, RusotoError<ListTypesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ListTypes");
let mut params = params;
ListTypesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListTypesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListTypesOutputDeserializer::deserialize("ListTypesResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn record_handler_progress(
&self,
input: RecordHandlerProgressInput,
) -> Result<RecordHandlerProgressOutput, RusotoError<RecordHandlerProgressError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("RecordHandlerProgress");
let mut params = params;
RecordHandlerProgressInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, RecordHandlerProgressError::from_response)
.await?;
let result = RecordHandlerProgressOutput::default();
drop(response);
Ok(result)
}
async fn register_type(
&self,
input: RegisterTypeInput,
) -> Result<RegisterTypeOutput, RusotoError<RegisterTypeError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("RegisterType");
let mut params = params;
RegisterTypeInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, RegisterTypeError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = RegisterTypeOutputDeserializer::deserialize("RegisterTypeResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn set_stack_policy(
&self,
input: SetStackPolicyInput,
) -> Result<(), RusotoError<SetStackPolicyError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("SetStackPolicy");
let mut params = params;
SetStackPolicyInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, SetStackPolicyError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn set_type_default_version(
&self,
input: SetTypeDefaultVersionInput,
) -> Result<SetTypeDefaultVersionOutput, RusotoError<SetTypeDefaultVersionError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("SetTypeDefaultVersion");
let mut params = params;
SetTypeDefaultVersionInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, SetTypeDefaultVersionError::from_response)
.await?;
let result = SetTypeDefaultVersionOutput::default();
drop(response);
Ok(result)
}
async fn signal_resource(
&self,
input: SignalResourceInput,
) -> Result<(), RusotoError<SignalResourceError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("SignalResource");
let mut params = params;
SignalResourceInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, SignalResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn stop_stack_set_operation(
&self,
input: StopStackSetOperationInput,
) -> Result<StopStackSetOperationOutput, RusotoError<StopStackSetOperationError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("StopStackSetOperation");
let mut params = params;
StopStackSetOperationInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, StopStackSetOperationError::from_response)
.await?;
let result = StopStackSetOperationOutput::default();
drop(response);
Ok(result)
}
async fn update_stack(
&self,
input: UpdateStackInput,
) -> Result<UpdateStackOutput, RusotoError<UpdateStackError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("UpdateStack");
let mut params = params;
UpdateStackInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateStackError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateStackOutputDeserializer::deserialize("UpdateStackResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_stack_instances(
&self,
input: UpdateStackInstancesInput,
) -> Result<UpdateStackInstancesOutput, RusotoError<UpdateStackInstancesError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("UpdateStackInstances");
let mut params = params;
UpdateStackInstancesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateStackInstancesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateStackInstancesOutputDeserializer::deserialize(
"UpdateStackInstancesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_stack_set(
&self,
input: UpdateStackSetInput,
) -> Result<UpdateStackSetOutput, RusotoError<UpdateStackSetError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("UpdateStackSet");
let mut params = params;
UpdateStackSetInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateStackSetError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
UpdateStackSetOutputDeserializer::deserialize("UpdateStackSetResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_termination_protection(
&self,
input: UpdateTerminationProtectionInput,
) -> Result<UpdateTerminationProtectionOutput, RusotoError<UpdateTerminationProtectionError>>
{
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("UpdateTerminationProtection");
let mut params = params;
UpdateTerminationProtectionInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateTerminationProtectionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateTerminationProtectionOutputDeserializer::deserialize(
"UpdateTerminationProtectionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn validate_template(
&self,
input: ValidateTemplateInput,
) -> Result<ValidateTemplateOutput, RusotoError<ValidateTemplateError>> {
let mut request = SignedRequest::new("POST", "cloudformation", &self.region, "/");
let params = self.new_params("ValidateTemplate");
let mut params = params;
ValidateTemplateInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ValidateTemplateError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
ValidateTemplateOutputDeserializer::deserialize("ValidateTemplateResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[tokio::test]
async fn test_parse_error_cloudformation_cancel_update_stack() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/error",
"cloudformation-cancel-update-stack.xml",
);
let mock = MockRequestDispatcher::with_status(400).with_body(&mock_response);
let client =
CloudFormationClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CancelUpdateStackInput::default();
let result = client.cancel_update_stack(request).await;
assert!(!result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudformation_describe_stacks() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudformation-describe-stacks.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFormationClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeStacksInput::default();
let result = client.describe_stacks(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudformation_get_template() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudformation-get-template.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFormationClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetTemplateInput::default();
let result = client.get_template(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudformation_list_stacks() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudformation-list-stacks.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFormationClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListStacksInput::default();
let result = client.list_stacks(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
}