AWS SDK

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_tags_for_resources.rs

@@ -3,3 +125,110 @@

 pub fn de_list_tags_for_resources_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_tags_for_resources::ListTagsForResourcesOutput,
     crate::operation::list_tags_for_resources::ListTagsForResourcesError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::list_tags_for_resources::ListTagsForResourcesError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchHealthCheck" => crate::operation::list_tags_for_resources::ListTagsForResourcesError::NoSuchHealthCheck({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
                 output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
                     .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchHostedZone" => crate::operation::list_tags_for_resources::ListTagsForResourcesError::NoSuchHostedZone({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
                 output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
                     .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "PriorRequestNotComplete" => crate::operation::list_tags_for_resources::ListTagsForResourcesError::PriorRequestNotComplete({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
                 output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
                     .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ThrottlingException" => crate::operation::list_tags_for_resources::ListTagsForResourcesError::ThrottlingException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
                 output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_xml_err(_response_body, output)
                     .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::list_tags_for_resources::ListTagsForResourcesError::generic(generic),
     })
-85
+}
-86
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_tags_for_resources_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_tags_for_resources::ListTagsForResourcesOutput,
     crate::operation::list_tags_for_resources::ListTagsForResourcesError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_tags_for_resources::builders::ListTagsForResourcesOutputBuilder::default();
         output = crate::protocol_serde::shape_list_tags_for_resources::de_list_tags_for_resources(_response_body, output)
             .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_tags_for_resources_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_tags_for_resources::ListTagsForResourcesError::unhandled)?
     })
-106
+}
-107
 pub fn ser_list_tags_for_resources_op_input(
     input: &crate::operation::list_tags_for_resources::ListTagsForResourcesInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_traffic_policies.rs

@@ -3,3 +65,62 @@

↥ Expand context

 pub fn de_list_traffic_policies_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policies::ListTrafficPoliciesOutput,
     crate::operation::list_traffic_policies::ListTrafficPoliciesError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_traffic_policies::ListTrafficPoliciesError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::list_traffic_policies::ListTrafficPoliciesError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::list_traffic_policies::ListTrafficPoliciesError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::list_traffic_policies::ListTrafficPoliciesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::list_traffic_policies::ListTrafficPoliciesError::generic(generic),
     })
-37
+}
-38
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_traffic_policies_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policies::ListTrafficPoliciesOutput,
     crate::operation::list_traffic_policies::ListTrafficPoliciesError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_traffic_policies::builders::ListTrafficPoliciesOutputBuilder::default();
         output = crate::protocol_serde::shape_list_traffic_policies::de_list_traffic_policies(_response_body, output)
             .map_err(crate::operation::list_traffic_policies::ListTrafficPoliciesError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_traffic_policies_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_traffic_policies::ListTrafficPoliciesError::unhandled)?
     })
-58
+}
-59
 #[allow(unused_mut)]
 pub fn de_list_traffic_policies(
     inp: &[u8],

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_traffic_policy_instances.rs

@@ -3,3 +84,78 @@

↥ Expand context

 pub fn de_list_traffic_policy_instances_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesOutput,
     crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchTrafficPolicyInstance" => {
             crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::NoSuchTrafficPolicyInstance({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::NoSuchTrafficPolicyInstanceBuilder::default();
                     output = crate::protocol_serde::shape_no_such_traffic_policy_instance::de_no_such_traffic_policy_instance_xml_err(
                         _response_body,
                         output,
-44
+                    )
                     .map_err(crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::unhandled)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-51
+        }
         _ => crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::generic(generic),
     })
-54
+}
-55
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_traffic_policy_instances_http_response(
     _response_status: u16,

↧ Expand context

     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesOutput,
     crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_traffic_policy_instances::builders::ListTrafficPolicyInstancesOutputBuilder::default();
         output = crate::protocol_serde::shape_list_traffic_policy_instances::de_list_traffic_policy_instances(_response_body, output)
             .map_err(crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_traffic_policy_instances_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesError::unhandled)?
     })
-75
+}
-76
 #[allow(unused_mut)]
 pub fn de_list_traffic_policy_instances(

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_traffic_policy_instances_by_hosted_zone.rs

@@ -9,9 +112,103 @@

↥ Expand context

     crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => {
             return Err(
                 crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled(generic),
-21
+            )
-22
+        }
     };
-24
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "InvalidInput" => {
             crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::InvalidInput({

                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                     output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output).map_err(
                         crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled,
                     )?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-41
+        }
         "NoSuchHostedZone" => {
             crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::NoSuchHostedZone({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
                     output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output).map_err(
                         crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled,
                     )?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-56
+        }
         "NoSuchTrafficPolicyInstance" => {
             crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::NoSuchTrafficPolicyInstance(
-59
+                {
                     #[allow(unused_mut)]
                     let mut tmp = {
                         #[allow(unused_mut)]
                         let mut output = crate::types::error::builders::NoSuchTrafficPolicyInstanceBuilder::default();
                         output = crate::protocol_serde::shape_no_such_traffic_policy_instance::de_no_such_traffic_policy_instance_xml_err(
                             _response_body,
                             output,
-67
+                        )
                         .map_err(
                             crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled,
                         )?;
                         let output = output.meta(generic);
                         output.build()
                     };
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
--
+                    }
                     tmp
                 },
-76
+            )
-77
+        }
         _ => crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::generic(generic),
     })
-80
+}
-81
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_traffic_policy_instances_by_hosted_zone_http_response(

↧ Expand context

     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneOutput,
     crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::list_traffic_policy_instances_by_hosted_zone::builders::ListTrafficPolicyInstancesByHostedZoneOutputBuilder::default();
         output = crate::protocol_serde::shape_list_traffic_policy_instances_by_hosted_zone::de_list_traffic_policy_instances_by_hosted_zone(
             _response_body,
             output,
-98
+        )
         .map_err(crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_traffic_policy_instances_by_hosted_zone_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_traffic_policy_instances_by_hosted_zone::ListTrafficPolicyInstancesByHostedZoneError::unhandled)?

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_traffic_policy_instances_by_policy.rs

@@ -3,3 +101,92 @@

↥ Expand context

 pub fn de_list_traffic_policy_instances_by_policy_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyOutput,
     crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchTrafficPolicy" => {
             crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::NoSuchTrafficPolicy({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
                     output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
                         .map_err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-48
+        }
         "NoSuchTrafficPolicyInstance" => {
             crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::NoSuchTrafficPolicyInstance({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::NoSuchTrafficPolicyInstanceBuilder::default();
                     output = crate::protocol_serde::shape_no_such_traffic_policy_instance::de_no_such_traffic_policy_instance_xml_err(
                         _response_body,
                         output,
-58
+                    )
                     .map_err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-65
+        }
         _ => crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::generic(generic),
     })
-68
+}
-69
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_traffic_policy_instances_by_policy_http_response(
     _response_status: u16,

↧ Expand context

     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyOutput,
     crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::list_traffic_policy_instances_by_policy::builders::ListTrafficPolicyInstancesByPolicyOutputBuilder::default();
         output =
             crate::protocol_serde::shape_list_traffic_policy_instances_by_policy::de_list_traffic_policy_instances_by_policy(_response_body, output)
                 .map_err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_traffic_policy_instances_by_policy_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError::unhandled)?
     })
-91
+}
-92

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_traffic_policy_versions.rs

@@ -7,7 +84,78 @@

↥ Expand context

 ) -> std::result::Result<
     crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsOutput,
     crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => {
             return Err(crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::unhandled(
                 generic,
             ))
-22
+        }
     };
-24
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchTrafficPolicy" => crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::NoSuchTrafficPolicy({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
                 output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
                     .map_err(crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::generic(generic),
     })
-53
+}
-54
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_traffic_policy_versions_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsOutput,
     crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_traffic_policy_versions::builders::ListTrafficPolicyVersionsOutputBuilder::default();
         output = crate::protocol_serde::shape_list_traffic_policy_versions::de_list_traffic_policy_versions(_response_body, output)
             .map_err(crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_traffic_policy_versions_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError::unhandled)?
     })
-74
+}
-75
 #[allow(unused_mut)]
 pub fn de_list_traffic_policy_versions(
     inp: &[u8],

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_list_vpc_association_authorizations.rs

@@ -3,3 +97,88 @@

↥ Expand context

 pub fn de_list_vpc_association_authorizations_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsOutput,
     crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InvalidPaginationToken" => {
             crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::InvalidPaginationToken({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::InvalidPaginationTokenBuilder::default();
                     output = crate::protocol_serde::shape_invalid_pagination_token::de_invalid_pagination_token_xml_err(_response_body, output)
                         .map_err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-48
+        }
         "NoSuchHostedZone" => crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::NoSuchHostedZone({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
                 output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
                     .map_err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::generic(generic),
     })
-63
+}
-64
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_vpc_association_authorizations_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsOutput,
     crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_vpc_association_authorizations::builders::ListVpcAssociationAuthorizationsOutputBuilder::default();
         output = crate::protocol_serde::shape_list_vpc_association_authorizations::de_list_vpc_association_authorizations(_response_body, output)
             .map_err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::list_vpc_association_authorizations_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError::unhandled)?
     })
-84
+}
-85
 #[allow(unused_mut)]
 pub fn de_list_vpc_association_authorizations(
     inp: &[u8],

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_test_dns_answer.rs

@@ -1,1 +77,71 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_test_dns_answer_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::test_dns_answer::TestDnsAnswerOutput, crate::operation::test_dns_answer::TestDNSAnswerError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::test_dns_answer::TestDNSAnswerError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::test_dns_answer::TestDNSAnswerError::unhandled(generic)),
     };
-17
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::test_dns_answer::TestDNSAnswerError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::test_dns_answer::TestDNSAnswerError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchHostedZone" => crate::operation::test_dns_answer::TestDNSAnswerError::NoSuchHostedZone({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
                 output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
                     .map_err(crate::operation::test_dns_answer::TestDNSAnswerError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::test_dns_answer::TestDNSAnswerError::generic(generic),
     })
-46
+}
-47
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_test_dns_answer_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::test_dns_answer::TestDnsAnswerOutput, crate::operation::test_dns_answer::TestDNSAnswerError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::test_dns_answer::builders::TestDnsAnswerOutputBuilder::default();
         output = crate::protocol_serde::shape_test_dns_answer::de_test_dns_answer(_response_body, output)
             .map_err(crate::operation::test_dns_answer::TestDNSAnswerError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::test_dns_answer_output_output_correct_errors(output)
             .build()
             .map_err(crate::operation::test_dns_answer::TestDNSAnswerError::unhandled)?
     })
-64
+}
-65
 #[allow(unused_mut)]
 pub fn de_test_dns_answer(
     inp: &[u8],
     mut builder: crate::operation::test_dns_answer::builders::TestDnsAnswerOutputBuilder,
 ) -> std::result::Result<crate::operation::test_dns_answer::builders::TestDnsAnswerOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_update_health_check.rs

@@ -1,1 +93,84 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_update_health_check_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::update_health_check::UpdateHealthCheckOutput, crate::operation::update_health_check::UpdateHealthCheckError>
-8
+{
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::update_health_check::UpdateHealthCheckError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::update_health_check::UpdateHealthCheckError::unhandled(generic)),
     };
-18
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "HealthCheckVersionMismatch" => crate::operation::update_health_check::UpdateHealthCheckError::HealthCheckVersionMismatch({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::HealthCheckVersionMismatchBuilder::default();
                 output = crate::protocol_serde::shape_health_check_version_mismatch::de_health_check_version_mismatch_xml_err(_response_body, output)
                     .map_err(crate::operation::update_health_check::UpdateHealthCheckError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InvalidInput" => crate::operation::update_health_check::UpdateHealthCheckError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::update_health_check::UpdateHealthCheckError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchHealthCheck" => crate::operation::update_health_check::UpdateHealthCheckError::NoSuchHealthCheck({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
                 output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
                     .map_err(crate::operation::update_health_check::UpdateHealthCheckError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::update_health_check::UpdateHealthCheckError::generic(generic),
     })
-59
+}
-60
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_update_health_check_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::update_health_check::UpdateHealthCheckOutput, crate::operation::update_health_check::UpdateHealthCheckError>
-67
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::update_health_check::builders::UpdateHealthCheckOutputBuilder::default();
         output = crate::protocol_serde::shape_update_health_check::de_update_health_check(_response_body, output)
             .map_err(crate::operation::update_health_check::UpdateHealthCheckError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::update_health_check_output_output_correct_errors(output).build()
     })
-76
+}
-77
 pub fn ser_update_health_check_op_input(
     input: &crate::operation::update_health_check::UpdateHealthCheckInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-82
+    {
         let mut writer = ::aws_smithy_xml::encode::XmlWriter::new(&mut out);
         #[allow(unused_mut)]

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_update_hosted_zone_comment.rs

@@ -7,7 +99,90 @@

↥ Expand context

 ) -> std::result::Result<
     crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentOutput,
     crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => {
             return Err(crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::unhandled(
                 generic,
             ))
-22
+        }
     };
-24
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "InvalidInput" => crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchHostedZone" => crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::NoSuchHostedZone({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
                 output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
                     .map_err(crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "PriorRequestNotComplete" => crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::PriorRequestNotComplete({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
                 output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
                     .map_err(crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::generic(generic),
     })
-65
+}
-66
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_update_hosted_zone_comment_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentOutput,
     crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::update_hosted_zone_comment::builders::UpdateHostedZoneCommentOutputBuilder::default();
         output = crate::protocol_serde::shape_update_hosted_zone_comment::de_update_hosted_zone_comment(_response_body, output)
             .map_err(crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::update_hosted_zone_comment_output_output_correct_errors(output).build()
     })
-84
+}
-85
 pub fn ser_update_hosted_zone_comment_op_input(
     input: &crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-90
+    {

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_update_traffic_policy_comment.rs

@@ -3,3 +95,86 @@

↥ Expand context

 pub fn de_update_traffic_policy_comment_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentOutput,
     crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ConcurrentModification" => crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::ConcurrentModification({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
                 output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InvalidInput" => crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchTrafficPolicy" => crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::NoSuchTrafficPolicy({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
                 output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::generic(generic),
     })
-61
+}
-62
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_update_traffic_policy_comment_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentOutput,
     crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::update_traffic_policy_comment::builders::UpdateTrafficPolicyCommentOutputBuilder::default();
         output = crate::protocol_serde::shape_update_traffic_policy_comment::de_update_traffic_policy_comment(_response_body, output)
             .map_err(crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::update_traffic_policy_comment_output_output_correct_errors(output).build()
     })
-80
+}
-81
 pub fn ser_update_traffic_policy_comment_op_input(
     input: &crate::operation::update_traffic_policy_comment::UpdateTrafficPolicyCommentInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-86
+    {

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_update_traffic_policy_instance.rs

@@ -3,3 +130,115 @@

↥ Expand context

 pub fn de_update_traffic_policy_instance_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceOutput,
     crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled(generic)),
     };
-20
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "ConflictingTypes" => crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::ConflictingTypes({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ConflictingTypesBuilder::default();
                 output = crate::protocol_serde::shape_conflicting_types::de_conflicting_types_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InvalidInput" => crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::InvalidInput({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InvalidInputBuilder::default();
                 output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchTrafficPolicy" => crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::NoSuchTrafficPolicy({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
                 output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "NoSuchTrafficPolicyInstance" => {
             crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::NoSuchTrafficPolicyInstanceBuilder::default();
                     output = crate::protocol_serde::shape_no_such_traffic_policy_instance::de_no_such_traffic_policy_instance_xml_err(
                         _response_body,
                         output,
-68
+                    )
                     .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
--
+                }
                 tmp
             })
-75
+        }
         "PriorRequestNotComplete" => crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::PriorRequestNotComplete({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
                 output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
                     .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::generic(generic),
     })
-90
+}
-91
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_update_traffic_policy_instance_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceOutput,
     crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::update_traffic_policy_instance::builders::UpdateTrafficPolicyInstanceOutputBuilder::default();
         output = crate::protocol_serde::shape_update_traffic_policy_instance::de_update_traffic_policy_instance(_response_body, output)
             .map_err(crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::update_traffic_policy_instance_output_output_correct_errors(output).build()
     })
-109
+}
-110
 pub fn ser_update_traffic_policy_instance_op_input(
     input: &crate::operation::update_traffic_policy_instance::UpdateTrafficPolicyInstanceInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-115
+    {

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_abort_multipart_upload.rs

@@ -4,4 +66,63 @@

↥ Expand context

     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::abort_multipart_upload::AbortMultipartUploadOutput,
     crate::operation::abort_multipart_upload::AbortMultipartUploadError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled(generic)),
     };
-21
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "NoSuchUpload" => crate::operation::abort_multipart_upload::AbortMultipartUploadError::NoSuchUpload({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchUploadBuilder::default();
                 output = crate::protocol_serde::shape_no_such_upload::de_no_such_upload_xml_err(_response_body, output)
                     .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::abort_multipart_upload::AbortMultipartUploadError::generic(generic),
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_abort_multipart_upload_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::abort_multipart_upload::AbortMultipartUploadOutput,
     crate::operation::abort_multipart_upload::AbortMultipartUploadError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::abort_multipart_upload::builders::AbortMultipartUploadOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_abort_multipart_upload_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled(
                     "Failed to parse RequestCharged from header `x-amz-request-charged",
-56
+                )
             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-63
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_copy_object.rs

@@ -2,2 +64,61 @@

↥ Expand context

 #[allow(clippy::unnecessary_wraps)]
 pub fn de_copy_object_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::copy_object::CopyObjectOutput, crate::operation::copy_object::CopyObjectError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::copy_object::CopyObjectError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::copy_object::CopyObjectError::unhandled(generic)),
     };
-18
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "ObjectNotInActiveTierError" => crate::operation::copy_object::CopyObjectError::ObjectNotInActiveTierError({

             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ObjectNotInActiveTierErrorBuilder::default();
                 output =
                     crate::protocol_serde::shape_object_not_in_active_tier_error::de_object_not_in_active_tier_error_xml_err(_response_body, output)
                         .map_err(crate::operation::copy_object::CopyObjectError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::copy_object::CopyObjectError::generic(generic),
     })
-36
+}
-37
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_copy_object_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::copy_object::CopyObjectOutput, crate::operation::copy_object::CopyObjectError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::copy_object::builders::CopyObjectOutputBuilder::default();
         output = output.set_bucket_key_enabled(
             crate::protocol_serde::shape_copy_object_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
                 crate::operation::copy_object::CopyObjectError::unhandled(
                     "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
-51
+                )
             })?,
         );
         output = output.set_copy_object_result(crate::protocol_serde::shape_copy_object_output::de_copy_object_result_payload(
             _response_body,
         )?);
         output = output.set_copy_source_version_id(
             crate::protocol_serde::shape_copy_object_output::de_copy_source_version_id_header(_response_headers).map_err(|_| {
                 crate::operation::copy_object::CopyObjectError::unhandled(
                     "Failed to parse CopySourceVersionId from header `x-amz-copy-source-version-id",
-61
+                )

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_bucket.rs

@@ -1,1 +78,72 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_bucket_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::create_bucket::CreateBucketOutput, crate::operation::create_bucket::CreateBucketError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::create_bucket::CreateBucketError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::create_bucket::CreateBucketError::unhandled(generic)),
     };
-18
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "BucketAlreadyExists" => crate::operation::create_bucket::CreateBucketError::BucketAlreadyExists({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::BucketAlreadyExistsBuilder::default();
                 output = crate::protocol_serde::shape_bucket_already_exists::de_bucket_already_exists_xml_err(_response_body, output)
                     .map_err(crate::operation::create_bucket::CreateBucketError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "BucketAlreadyOwnedByYou" => crate::operation::create_bucket::CreateBucketError::BucketAlreadyOwnedByYou({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::BucketAlreadyOwnedByYouBuilder::default();
                 output = crate::protocol_serde::shape_bucket_already_owned_by_you::de_bucket_already_owned_by_you_xml_err(_response_body, output)
                     .map_err(crate::operation::create_bucket::CreateBucketError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::create_bucket::CreateBucketError::generic(generic),
     })
-47
+}
-48
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_bucket_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::create_bucket::CreateBucketOutput, crate::operation::create_bucket::CreateBucketError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::create_bucket::builders::CreateBucketOutputBuilder::default();
         output = output.set_location(
             crate::protocol_serde::shape_create_bucket_output::de_location_header(_response_headers)
                 .map_err(|_| crate::operation::create_bucket::CreateBucketError::unhandled("Failed to parse Location from header `Location"))?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-66
+}
-67
 pub fn ser_create_bucket_headers(
     input: &crate::operation::create_bucket::CreateBucketInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.acl {

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_session.rs

@@ -1,1 +63,60 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_session_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::create_session::CreateSessionOutput, crate::operation::create_session::CreateSessionError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::create_session::CreateSessionError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => return Err(crate::operation::create_session::CreateSessionError::unhandled(generic)),
     };
-18
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {

         "NoSuchBucket" => crate::operation::create_session::CreateSessionError::NoSuchBucket({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::NoSuchBucketBuilder::default();
                 output = crate::protocol_serde::shape_no_such_bucket::de_no_such_bucket_xml_err(_response_body, output)
                     .map_err(crate::operation::create_session::CreateSessionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::create_session::CreateSessionError::generic(generic),
     })
-35
+}
-36
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_session_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,

↧ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::create_session::CreateSessionOutput, crate::operation::create_session::CreateSessionError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::create_session::builders::CreateSessionOutputBuilder::default();
         output = crate::protocol_serde::shape_create_session::de_create_session(_response_body, output)
             .map_err(crate::operation::create_session::CreateSessionError::unhandled)?;
         output = output.set_bucket_key_enabled(
             crate::protocol_serde::shape_create_session_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
                 crate::operation::create_session::CreateSessionError::unhandled(
                     "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
-52
+                )
             })?,
         );
         output = output.set_ssekms_encryption_context(
             crate::protocol_serde::shape_create_session_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
                 crate::operation::create_session::CreateSessionError::unhandled(
                     "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
-59
+                )
             })?,

AWS SDK

Files changed: