AWS SDK

rev. a7fb2e3446d314cfbe48069306e4e0a389b39aeb

Files changed:

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

@@ -8,8 +70,76 @@

     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::put_bucket_logging::PutBucketLoggingError::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();
     Err(crate::operation::put_bucket_logging::PutBucketLoggingError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_logging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::put_bucket_logging::PutBucketLoggingOutput, crate::operation::put_bucket_logging::PutBucketLoggingError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_logging::builders::PutBucketLoggingOutputBuilder::default();
         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()
     })
-30
+}
-31
 pub fn ser_put_bucket_logging_headers(
     input: &crate::operation::put_bucket_logging::PutBucketLoggingInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-48
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-61
+    }
     if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-74
+    }
     Ok(builder)
-76
+}

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

@@ -14,14 +54,56 @@

↥ Expand context

     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();
     Err(crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_metrics_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationOutput,
     crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_metrics_configuration::builders::PutBucketMetricsConfigurationOutputBuilder::default();
         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()
     })
-36
+}
-37
 pub fn ser_put_bucket_metrics_configuration_headers(
     input: &crate::operation::put_bucket_metrics_configuration::PutBucketMetricsConfigurationInput,
     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.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-54
+    }
     Ok(builder)
-56
+}

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

@@ -15,15 +67,71 @@

↥ Expand context

     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_notification_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationOutput,
     crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::put_bucket_notification_configuration::builders::PutBucketNotificationConfigurationOutputBuilder::default();
         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()
     })
-37
+}
-38
 pub fn ser_put_bucket_notification_configuration_headers(
     input: &crate::operation::put_bucket_notification_configuration::PutBucketNotificationConfigurationInput,
     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.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-55
+    }
     if let ::std::option::Option::Some(inner_3) = &input.skip_destination_validation {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
         let formatted_4 = encoder.encode();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "skip_destination_validation",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-skip-destination-validation", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "skip_destination_validation",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-skip-destination-validation", header_value);
-+
+        }
-69
+    }
     Ok(builder)
-71
+}

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

@@ -16,16 +67,71 @@

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsError::generic(
         generic,
     ))
-20
+}
-21
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_ownership_controls_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsOutput,
     crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_ownership_controls::builders::PutBucketOwnershipControlsOutputBuilder::default();
         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()
     })
-38
+}
-39
 pub fn ser_put_bucket_ownership_controls_headers(
     input: &crate::operation::put_bucket_ownership_controls::PutBucketOwnershipControlsInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-56
+    }
     if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-69
+    }
     Ok(builder)
-71
+}

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

@@ -8,8 +82,90 @@

↥ Expand context

     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::put_bucket_policy::PutBucketPolicyError::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();
     Err(crate::operation::put_bucket_policy::PutBucketPolicyError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_policy_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::put_bucket_policy::PutBucketPolicyOutput, crate::operation::put_bucket_policy::PutBucketPolicyError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_policy::builders::PutBucketPolicyOutputBuilder::default();
         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()
     })
-30
+}
-31
 pub fn ser_put_bucket_policy_headers(
     input: &crate::operation::put_bucket_policy::PutBucketPolicyInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-48
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-61
+    }
     if let ::std::option::Option::Some(inner_5) = &input.confirm_remove_self_bucket_access {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
         let formatted_6 = encoder.encode();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "confirm_remove_self_bucket_access",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-confirm-remove-self-bucket-access", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "confirm_remove_self_bucket_access",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-confirm-remove-self-bucket-access", header_value);
-+
+        }
-75
+    }
     if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-88
+    }
     Ok(builder)
-90
+}

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

@@ -14,14 +87,95 @@

↥ Expand context

     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();
     Err(crate::operation::put_bucket_replication::PutBucketReplicationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_replication_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_bucket_replication::PutBucketReplicationOutput,
     crate::operation::put_bucket_replication::PutBucketReplicationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_replication::builders::PutBucketReplicationOutputBuilder::default();
         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()
     })
-36
+}
-37
 pub fn ser_put_bucket_replication_headers(
     input: &crate::operation::put_bucket_replication::PutBucketReplicationInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-54
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-67
+    }
     if let ::std::option::Option::Some(inner_5) = &input.token {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "token",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-bucket-object-lock-token", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "token",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-bucket-object-lock-token", header_value);
-+
+        }
-80
+    }
     if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-93
+    }
     Ok(builder)
-95
+}

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

@@ -16,16 +78,84 @@

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError::generic(
         generic,
     ))
-20
+}
-21
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_request_payment_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_bucket_request_payment::PutBucketRequestPaymentOutput,
     crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_request_payment::builders::PutBucketRequestPaymentOutputBuilder::default();
         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()
     })
-38
+}
-39
 pub fn ser_put_bucket_request_payment_headers(
     input: &crate::operation::put_bucket_request_payment::PutBucketRequestPaymentInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-56
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-69
+    }
     if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-82
+    }
     Ok(builder)
-84
+}

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

@@ -8,8 +70,76 @@

↥ Expand context

     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::put_bucket_tagging::PutBucketTaggingError::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();
     Err(crate::operation::put_bucket_tagging::PutBucketTaggingError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_tagging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::put_bucket_tagging::PutBucketTaggingOutput, crate::operation::put_bucket_tagging::PutBucketTaggingError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_tagging::builders::PutBucketTaggingOutputBuilder::default();
         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()
     })
-30
+}
-31
 pub fn ser_put_bucket_tagging_headers(
     input: &crate::operation::put_bucket_tagging::PutBucketTaggingInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-48
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-61
+    }
     if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-74
+    }
     Ok(builder)
-76
+}

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

@@ -14,14 +87,95 @@

↥ Expand context

     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();
     Err(crate::operation::put_bucket_versioning::PutBucketVersioningError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_versioning_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_bucket_versioning::PutBucketVersioningOutput,
     crate::operation::put_bucket_versioning::PutBucketVersioningError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_versioning::builders::PutBucketVersioningOutputBuilder::default();
         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()
     })
-36
+}
-37
 pub fn ser_put_bucket_versioning_headers(
     input: &crate::operation::put_bucket_versioning::PutBucketVersioningInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-54
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-67
+    }
     if let ::std::option::Option::Some(inner_5) = &input.mfa {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "mfa",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-mfa", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "mfa",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-mfa", header_value);
-+
+        }
-80
+    }
     if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-93
+    }
     Ok(builder)
-95
+}

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

@@ -8,8 +70,76 @@

↥ Expand context

     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::put_bucket_website::PutBucketWebsiteError::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();
     Err(crate::operation::put_bucket_website::PutBucketWebsiteError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_bucket_website_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::put_bucket_website::PutBucketWebsiteOutput, crate::operation::put_bucket_website::PutBucketWebsiteError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_bucket_website::builders::PutBucketWebsiteOutputBuilder::default();
         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()
     })
-30
+}
-31
 pub fn ser_put_bucket_website_headers(
     input: &crate::operation::put_bucket_website::PutBucketWebsiteInput,
     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.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-48
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-61
+    }
     if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-74
+    }
     Ok(builder)
-76
+}

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

@@ -87,87 +502,568 @@

↥ Expand context

         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_put_object_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::put_object::PutObjectError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-91
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_put_object_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::put_object::PutObjectError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-98
+                )
             })?,
         );
         output = output.set_version_id(
             crate::protocol_serde::shape_put_object_output::de_version_id_header(_response_headers)
                 .map_err(|_| crate::operation::put_object::PutObjectError::unhandled("Failed to parse VersionId from header `x-amz-version-id"))?,
         );
         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()
     })
-109
+}
-110
 pub fn ser_put_object_headers(
     input: &crate::operation::put_object::PutObjectInput,
     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 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "acl",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-acl", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "acl",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-acl", header_value);
-+
+        }
-127
+    }
     if let ::std::option::Option::Some(inner_3) = &input.cache_control {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "cache_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Cache-Control", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "cache_control",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Cache-Control", header_value);
-+
+        }
-140
+    }
     if let ::std::option::Option::Some(inner_5) = &input.content_disposition {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_disposition",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-Disposition", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_disposition",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-Disposition", header_value);
-+
+        }
-153
+    }
     if let ::std::option::Option::Some(inner_7) = &input.content_encoding {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-Encoding", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_encoding",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-Encoding", header_value);
-+
+        }
-166
+    }
     if let ::std::option::Option::Some(inner_9) = &input.content_language {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-Language", header_value);
         if !formatted_10.is_empty() {
             let header_value = formatted_10;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_language",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-Language", header_value);
-+
+        }
-179
+    }
     if let ::std::option::Option::Some(inner_11) = &input.content_length {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_11);
         let formatted_12 = encoder.encode();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_length",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-Length", header_value);
         if !formatted_12.is_empty() {
             let header_value = formatted_12;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_length",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-Length", header_value);
-+
+        }
-193
+    }
     if let ::std::option::Option::Some(inner_13) = &input.content_md5 {
         let formatted_14 = inner_13.as_str();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
         if !formatted_14.is_empty() {
             let header_value = formatted_14;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-206
+    }
     if let ::std::option::Option::Some(inner_15) = &input.content_type {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-Type", header_value);
         if !formatted_16.is_empty() {
             let header_value = formatted_16;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-Type", header_value);
-+
+        }
-219
+    }
     if let ::std::option::Option::Some(inner_17) = &input.checksum_algorithm {
         let formatted_18 = inner_17.as_str();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_18.is_empty() {
             let header_value = formatted_18;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-232
+    }
     if let ::std::option::Option::Some(inner_19) = &input.checksum_crc32 {
         let formatted_20 = inner_19.as_str();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_crc32",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-checksum-crc32", header_value);
         if !formatted_20.is_empty() {
             let header_value = formatted_20;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_crc32",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-crc32", header_value);
-+
+        }
-245
+    }
     if let ::std::option::Option::Some(inner_21) = &input.checksum_crc32_c {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_crc32_c",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-checksum-crc32c", header_value);
         if !formatted_22.is_empty() {
             let header_value = formatted_22;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_crc32_c",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-crc32c", header_value);
-+
+        }
-258
+    }
     if let ::std::option::Option::Some(inner_23) = &input.checksum_sha1 {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_sha1",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-checksum-sha1", header_value);
         if !formatted_24.is_empty() {
             let header_value = formatted_24;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_sha1",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-sha1", header_value);
-+
+        }
-271
+    }
     if let ::std::option::Option::Some(inner_25) = &input.checksum_sha256 {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_sha256",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-checksum-sha256", header_value);
         if !formatted_26.is_empty() {
             let header_value = formatted_26;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_sha256",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-sha256", header_value);
-+
+        }
-284
+    }
     if let ::std::option::Option::Some(inner_27) = &input.expires {
         let formatted_28 = inner_27.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_28;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expires",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Expires", header_value);
         if !formatted_28.is_empty() {
             let header_value = formatted_28;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expires",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Expires", header_value);
-+
+        }
-297
+    }
     if let ::std::option::Option::Some(inner_29) = &input.grant_full_control {
         let formatted_30 = inner_29.as_str();
         let header_value = formatted_30;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_full_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-grant-full-control", header_value);
         if !formatted_30.is_empty() {
             let header_value = formatted_30;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "grant_full_control",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-full-control", header_value);
-+
+        }
-310
+    }
     if let ::std::option::Option::Some(inner_31) = &input.grant_read {
         let formatted_32 = inner_31.as_str();
         let header_value = formatted_32;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-grant-read", header_value);
         if !formatted_32.is_empty() {
             let header_value = formatted_32;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "grant_read",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-read", header_value);
-+
+        }
-323
+    }
     if let ::std::option::Option::Some(inner_33) = &input.grant_read_acp {
         let formatted_34 = inner_33.as_str();
         let header_value = formatted_34;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-grant-read-acp", header_value);
         if !formatted_34.is_empty() {
             let header_value = formatted_34;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "grant_read_acp",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-read-acp", header_value);
-+
+        }
-336
+    }
     if let ::std::option::Option::Some(inner_35) = &input.grant_write_acp {
         let formatted_36 = inner_35.as_str();
         let header_value = formatted_36;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_write_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-grant-write-acp", header_value);
         if !formatted_36.is_empty() {
             let header_value = formatted_36;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "grant_write_acp",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-write-acp", header_value);
-+
+        }
-349
+    }
     if let ::std::option::Option::Some(inner_37) = &input.server_side_encryption {
         let formatted_38 = inner_37.as_str();
         let header_value = formatted_38;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "server_side_encryption",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption", header_value);
         if !formatted_38.is_empty() {
             let header_value = formatted_38;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "server_side_encryption",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption", header_value);
-+
+        }
-362
+    }
     if let ::std::option::Option::Some(inner_39) = &input.storage_class {
         let formatted_40 = inner_39.as_str();
         let header_value = formatted_40;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "storage_class",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-storage-class", header_value);
         if !formatted_40.is_empty() {
             let header_value = formatted_40;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "storage_class",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-storage-class", header_value);
-+
+        }
-375
+    }
     if let ::std::option::Option::Some(inner_41) = &input.website_redirect_location {
         let formatted_42 = inner_41.as_str();
         let header_value = formatted_42;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "website_redirect_location",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-website-redirect-location", header_value);
         if !formatted_42.is_empty() {
             let header_value = formatted_42;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "website_redirect_location",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-website-redirect-location", header_value);
-+
+        }
-388
+    }
     if let ::std::option::Option::Some(inner_43) = &input.sse_customer_algorithm {
         let formatted_44 = inner_43.as_str();
         let header_value = formatted_44;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
         if !formatted_44.is_empty() {
             let header_value = formatted_44;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "sse_customer_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
-+
+        }
-401
+    }
     if let ::std::option::Option::Some(inner_45) = &input.sse_customer_key {
         let formatted_46 = inner_45.as_str();
         let header_value = formatted_46;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
         if !formatted_46.is_empty() {
             let header_value = formatted_46;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "sse_customer_key",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
-+
+        }
-414
+    }
     if let ::std::option::Option::Some(inner_47) = &input.sse_customer_key_md5 {
         let formatted_48 = inner_47.as_str();
         let header_value = formatted_48;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
         if !formatted_48.is_empty() {
             let header_value = formatted_48;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "sse_customer_key_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
-+
+        }
-427
+    }
     if let ::std::option::Option::Some(inner_49) = &input.ssekms_key_id {
         let formatted_50 = inner_49.as_str();
         let header_value = formatted_50;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_key_id",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
         if !formatted_50.is_empty() {
             let header_value = formatted_50;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "ssekms_key_id",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
-+
+        }
-440
+    }
     if let ::std::option::Option::Some(inner_51) = &input.ssekms_encryption_context {
         let formatted_52 = inner_51.as_str();
         let header_value = formatted_52;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_encryption_context",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-context", header_value);
         if !formatted_52.is_empty() {
             let header_value = formatted_52;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "ssekms_encryption_context",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption-context", header_value);
-+
+        }
-453
+    }
     if let ::std::option::Option::Some(inner_53) = &input.bucket_key_enabled {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_53);
         let formatted_54 = encoder.encode();
         let header_value = formatted_54;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "bucket_key_enabled",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
         if !formatted_54.is_empty() {
             let header_value = formatted_54;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "bucket_key_enabled",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
-+
+        }
-467
+    }
     if let ::std::option::Option::Some(inner_55) = &input.request_payer {
         let formatted_56 = inner_55.as_str();
         let header_value = formatted_56;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
         if !formatted_56.is_empty() {
             let header_value = formatted_56;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-480
+    }
     if let ::std::option::Option::Some(inner_57) = &input.tagging {
         let formatted_58 = inner_57.as_str();
         let header_value = formatted_58;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "tagging",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-tagging", header_value);
         if !formatted_58.is_empty() {
             let header_value = formatted_58;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "tagging",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-tagging", header_value);
-+
+        }
-493
+    }
     if let ::std::option::Option::Some(inner_59) = &input.object_lock_mode {
         let formatted_60 = inner_59.as_str();
         let header_value = formatted_60;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_mode",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-object-lock-mode", header_value);
         if !formatted_60.is_empty() {
             let header_value = formatted_60;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "object_lock_mode",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-object-lock-mode", header_value);
-+
+        }
-506
+    }
     if let ::std::option::Option::Some(inner_61) = &input.object_lock_retain_until_date {
         let formatted_62 = inner_61.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
         let header_value = formatted_62;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_retain_until_date",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
         if !formatted_62.is_empty() {
             let header_value = formatted_62;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "object_lock_retain_until_date",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
-+
+        }
-519
+    }
     if let ::std::option::Option::Some(inner_63) = &input.object_lock_legal_hold_status {
         let formatted_64 = inner_63.as_str();
         let header_value = formatted_64;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_legal_hold_status",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-object-lock-legal-hold", header_value);
         if !formatted_64.is_empty() {
             let header_value = formatted_64;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "object_lock_legal_hold_status",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-object-lock-legal-hold", header_value);
-+
+        }
-532
+    }
     if let ::std::option::Option::Some(inner_65) = &input.expected_bucket_owner {
         let formatted_66 = inner_65.as_str();
         let header_value = formatted_66;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_66.is_empty() {
             let header_value = formatted_66;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-545
+    }
     if let ::std::option::Option::Some(inner_67) = &input.metadata {
-547
+        {
             for (k, v) in inner_67 {
                 use std::str::FromStr;
                 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "metadata",
                         format!("`{k}` cannot be used as a header name: {err}"),
-554
+                    )

↧ Expand context

                 })?;
                 let header_value = v.as_str();
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "metadata",
                         format!("`{}` cannot be used as a header value: {}", v, err),
-561
+                    )
                 })?;
                 builder = builder.header(header_name, header_value);
-564
+            }
-565
+        }
-566
+    }
     Ok(builder)
-568
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17