AWS SDK

rev. a7fb2e3446d314cfbe48069306e4e0a389b39aeb

Files changed:

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

@@ -36,36 +175,195 @@

         _ => crate::operation::put_object_acl::PutObjectAclError::generic(generic),
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_object_acl_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::put_object_acl::PutObjectAclOutput, crate::operation::put_object_acl::PutObjectAclError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_object_acl::builders::PutObjectAclOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_put_object_acl_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::put_object_acl::PutObjectAclError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
             })?,
         );
         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()
     })
-58
+}
-59
 pub fn ser_put_object_acl_headers(
     input: &crate::operation::put_object_acl::PutObjectAclInput,
     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);
-+
+        }
-76
+    }
     if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
         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(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", 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(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-89
+    }
     if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
         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(
                 "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_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(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-102
+    }
     if let ::std::option::Option::Some(inner_7) = &input.grant_full_control {
         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(
                 "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_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(
                     "grant_full_control",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-full-control", header_value);
-+
+        }
-115
+    }
     if let ::std::option::Option::Some(inner_9) = &input.grant_read {
         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(
                 "grant_read",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-grant-read", 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(
                     "grant_read",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-read", header_value);
-+
+        }
-128
+    }
     if let ::std::option::Option::Some(inner_11) = &input.grant_read_acp {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         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_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(
                     "grant_read_acp",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-read-acp", header_value);
-+
+        }
-141
+    }
     if let ::std::option::Option::Some(inner_13) = &input.grant_write {
         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(
                 "grant_write",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-grant-write", 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(
                     "grant_write",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-write", header_value);
-+
+        }
-154
+    }
     if let ::std::option::Option::Some(inner_15) = &input.grant_write_acp {
         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(
                 "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_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(
                     "grant_write_acp",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-grant-write-acp", header_value);
-+
+        }
-167
+    }
     if let ::std::option::Option::Some(inner_17) = &input.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-180
+    }
     if let ::std::option::Option::Some(inner_19) = &input.expected_bucket_owner {
         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(
                 "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_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(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-193
+    }
     Ok(builder)
-195
+}

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

@@ -21,21 +94,102 @@

↥ Expand context

 pub fn de_put_object_legal_hold_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_object_legal_hold::PutObjectLegalHoldOutput,
     crate::operation::put_object_legal_hold::PutObjectLegalHoldError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_object_legal_hold::builders::PutObjectLegalHoldOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_put_object_legal_hold_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::put_object_legal_hold::PutObjectLegalHoldError::unhandled(
                     "Failed to parse RequestCharged from header `x-amz-request-charged",
-36
+                )
             })?,
         );
         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()
     })
-43
+}
-44
 pub fn ser_put_object_legal_hold_headers(
     input: &crate::operation::put_object_legal_hold::PutObjectLegalHoldInput,
     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.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-61
+    }
     if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
         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(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", 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(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-74
+    }
     if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
         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(
                 "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_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(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-87
+    }
     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);
-+
+        }
-100
+    }
     Ok(builder)
-102
+}

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

@@ -23,23 +107,117 @@

↥ Expand context

 pub fn de_put_object_lock_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_object_lock_configuration::PutObjectLockConfigurationOutput,
     crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_object_lock_configuration::builders::PutObjectLockConfigurationOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_put_object_lock_configuration_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError::unhandled(
                     "Failed to parse RequestCharged from header `x-amz-request-charged",
-38
+                )
             })?,
         );
         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()
     })
-45
+}
-46
 pub fn ser_put_object_lock_configuration_headers(
     input: &crate::operation::put_object_lock_configuration::PutObjectLockConfigurationInput,
     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.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-63
+    }
     if let ::std::option::Option::Some(inner_3) = &input.token {
         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(
                 "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_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(
                     "token",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-bucket-object-lock-token", header_value);
-+
+        }
-76
+    }
     if let ::std::option::Option::Some(inner_5) = &input.content_md5 {
         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_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", 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_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-89
+    }
     if let ::std::option::Option::Some(inner_7) = &input.checksum_algorithm {
         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(
                 "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_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(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-102
+    }
     if let ::std::option::Option::Some(inner_9) = &input.expected_bucket_owner {
         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(
                 "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_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(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-115
+    }
     Ok(builder)
-117
+}

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

@@ -21,21 +106,116 @@

↥ Expand context

 pub fn de_put_object_retention_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_object_retention::PutObjectRetentionOutput,
     crate::operation::put_object_retention::PutObjectRetentionError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_object_retention::builders::PutObjectRetentionOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_put_object_retention_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::put_object_retention::PutObjectRetentionError::unhandled(
                     "Failed to parse RequestCharged from header `x-amz-request-charged",
-36
+                )
             })?,
         );
         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()
     })
-43
+}
-44
 pub fn ser_put_object_retention_headers(
     input: &crate::operation::put_object_retention::PutObjectRetentionInput,
     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.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-61
+    }
     if let ::std::option::Option::Some(inner_3) = &input.bypass_governance_retention {
         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(
                 "bypass_governance_retention",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-bypass-governance-retention", 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(
                     "bypass_governance_retention",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-bypass-governance-retention", header_value);
-+
+        }
-75
+    }
     if let ::std::option::Option::Some(inner_5) = &input.content_md5 {
         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_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", 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_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-88
+    }
     if let ::std::option::Option::Some(inner_7) = &input.checksum_algorithm {
         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(
                 "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_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(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-101
+    }
     if let ::std::option::Option::Some(inner_9) = &input.expected_bucket_owner {
         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(
                 "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_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(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-114
+    }
     Ok(builder)
-116
+}

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

@@ -13,13 +86,94 @@

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::put_object_tagging::PutObjectTaggingError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_object_tagging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::put_object_tagging::PutObjectTaggingOutput, crate::operation::put_object_tagging::PutObjectTaggingError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_object_tagging::builders::PutObjectTaggingOutputBuilder::default();
         output = output.set_version_id(
             crate::protocol_serde::shape_put_object_tagging_output::de_version_id_header(_response_headers).map_err(|_| {
                 crate::operation::put_object_tagging::PutObjectTaggingError::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()
     })
-35
+}
-36
 pub fn ser_put_object_tagging_headers(
     input: &crate::operation::put_object_tagging::PutObjectTaggingInput,
     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);
-+
+        }
-53
+    }
     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);
-+
+        }
-66
+    }
     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);
-+
+        }
-79
+    }
     if let ::std::option::Option::Some(inner_7) = &input.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-92
+    }
     Ok(builder)
-94
+}

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

@@ -14,14 +76,82 @@

↥ 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_public_access_block::PutPublicAccessBlockError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_put_public_access_block_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::put_public_access_block::PutPublicAccessBlockOutput,
     crate::operation::put_public_access_block::PutPublicAccessBlockError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::put_public_access_block::builders::PutPublicAccessBlockOutputBuilder::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_public_access_block_headers(
     input: &crate::operation::put_public_access_block::PutPublicAccessBlockInput,
     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.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);
-+
+        }
-80
+    }
     Ok(builder)
-82
+}

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

@@ -46,46 +108,114 @@

↥ Expand context

     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::restore_object::RestoreObjectOutput, crate::operation::restore_object::RestoreObjectError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::restore_object::builders::RestoreObjectOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_restore_object_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::restore_object::RestoreObjectError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
             })?,
         );
         output = output.set_restore_output_path(
             crate::protocol_serde::shape_restore_object_output::de_restore_output_path_header(_response_headers).map_err(|_| {
                 crate::operation::restore_object::RestoreObjectError::unhandled(
                     "Failed to parse RestoreOutputPath from header `x-amz-restore-output-path",
-61
+                )
             })?,
         );
         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()
     })
-68
+}
-69
 pub fn ser_restore_object_headers(
     input: &crate::operation::restore_object::RestoreObjectInput,
     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.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-86
+    }
     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);
-+
+        }
-99
+    }
     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);
-+
+        }
-112
+    }
     Ok(builder)
-114
+}

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

@@ -23,23 +111,119 @@

↥ Expand context

         output
             .build()
             .map_err(crate::operation::select_object_content::SelectObjectContentError::unhandled)?
     })
-27
+}
-28
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_select_object_content_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::select_object_content::SelectObjectContentOutput,
     crate::operation::select_object_content::SelectObjectContentError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::select_object_content::SelectObjectContentError::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::select_object_content::SelectObjectContentError::generic(generic))
-45
+}
-46
 pub fn ser_select_object_content_headers(
     input: &crate::operation::select_object_content::SelectObjectContentInput,
     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.sse_customer_algorithm {
         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(
                 "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_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(
                     "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);
-+
+        }
-63
+    }
     if let ::std::option::Option::Some(inner_3) = &input.sse_customer_key {
         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(
                 "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_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(
                     "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);
-+
+        }
-76
+    }
     if let ::std::option::Option::Some(inner_5) = &input.sse_customer_key_md5 {
         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(
                 "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_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(
                     "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);
-+
+        }
-89
+    }
     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);
-+
+        }
-102
+    }
     Ok(builder)
-104
+}
-105
 pub fn ser_select_object_content_op_input(
     input: &crate::operation::select_object_content::SelectObjectContentInput,
 ) -> Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-110
+    {
         let mut writer = ::aws_smithy_xml::encode::XmlWriter::new(&mut out);

↧ Expand context

         #[allow(unused_mut)]
         let mut root = writer
             .start_el("SelectObjectContentRequest")
             .write_ns("http://s3.amazonaws.com/doc/2006-03-01/", None);
         crate::protocol_serde::shape_select_object_content_input::ser_select_object_content_input_input_input(input, root)?
-117
+    }
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-119
+}

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

@@ -73,73 +234,258 @@

↥ Expand context

-73
+                )
             })?,
         );
         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_upload_part_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::upload_part::UploadPartError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-80
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_upload_part_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::upload_part::UploadPartError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-87
+                )
             })?,
         );
         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()

     })
-94
+}
-95
 pub fn ser_upload_part_headers(
     input: &crate::operation::upload_part::UploadPartInput,
     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_length {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         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_length",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-Length", 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_length",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-Length", header_value);
-+
+        }
-113
+    }
     if let ::std::option::Option::Some(inner_3) = &input.content_md5 {
         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(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("Content-MD5", 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(
                     "content_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("Content-MD5", header_value);
-+
+        }
-126
+    }
     if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
         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(
                 "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_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(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-139
+    }
     if let ::std::option::Option::Some(inner_7) = &input.checksum_crc32 {
         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(
                 "checksum_crc32",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-checksum-crc32", 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(
                     "checksum_crc32",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-crc32", header_value);
-+
+        }
-152
+    }
     if let ::std::option::Option::Some(inner_9) = &input.checksum_crc32_c {
         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(
                 "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_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(
                     "checksum_crc32_c",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-crc32c", header_value);
-+
+        }
-165
+    }
     if let ::std::option::Option::Some(inner_11) = &input.checksum_sha1 {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         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_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(
                     "checksum_sha1",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-sha1", header_value);
-+
+        }
-178
+    }
     if let ::std::option::Option::Some(inner_13) = &input.checksum_sha256 {
         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(
                 "checksum_sha256",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-checksum-sha256", 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(
                     "checksum_sha256",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-checksum-sha256", header_value);
-+
+        }
-191
+    }
     if let ::std::option::Option::Some(inner_15) = &input.sse_customer_algorithm {
         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(
                 "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_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(
                     "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);
-+
+        }
-204
+    }
     if let ::std::option::Option::Some(inner_17) = &input.sse_customer_key {
         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(
                 "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_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(
                     "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);
-+
+        }
-217
+    }
     if let ::std::option::Option::Some(inner_19) = &input.sse_customer_key_md5 {
         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(
                 "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_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(
                     "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);
-+
+        }
-230
+    }
     if let ::std::option::Option::Some(inner_21) = &input.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-243
+    }
     if let ::std::option::Option::Some(inner_23) = &input.expected_bucket_owner {
         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(
                 "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_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(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-256
+    }
     Ok(builder)
-258
+}

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

@@ -60,60 +254,284 @@

↥ Expand context

                     "Failed to parse SSECustomerKeyMD5 from header `x-amz-server-side-encryption-customer-key-MD5",
-61
+                )
             })?,
         );
         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_upload_part_copy_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::upload_part_copy::UploadPartCopyError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-68
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_upload_part_copy_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::upload_part_copy::UploadPartCopyError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-75
+                )
             })?,
         );
         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()
     })
-82
+}
-83
 pub fn ser_upload_part_copy_headers(
     input: &crate::operation::upload_part_copy::UploadPartCopyInput,
     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.copy_source {
         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(
                 "copy_source",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source", 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(
                     "copy_source",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source", header_value);
-+
+        }
-100
+    }
     if let ::std::option::Option::Some(inner_3) = &input.copy_source_if_match {
         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(
                 "copy_source_if_match",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-match", 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(
                     "copy_source_if_match",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-if-match", header_value);
-+
+        }
-113
+    }
     if let ::std::option::Option::Some(inner_5) = &input.copy_source_if_modified_since {
         let formatted_6 = inner_5.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_if_modified_since",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-modified-since", 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(
                     "copy_source_if_modified_since",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
-+
+        }
-126
+    }
     if let ::std::option::Option::Some(inner_7) = &input.copy_source_if_none_match {
         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(
                 "copy_source_if_none_match",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-none-match", 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(
                     "copy_source_if_none_match",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-if-none-match", header_value);
-+
+        }
-139
+    }
     if let ::std::option::Option::Some(inner_9) = &input.copy_source_if_unmodified_since {
         let formatted_10 = inner_9.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_if_unmodified_since",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-unmodified-since", 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(
                     "copy_source_if_unmodified_since",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
-+
+        }
-152
+    }
     if let ::std::option::Option::Some(inner_11) = &input.copy_source_range {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_range",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-range", 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(
                     "copy_source_range",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-range", header_value);
-+
+        }
-165
+    }
     if let ::std::option::Option::Some(inner_13) = &input.sse_customer_algorithm {
         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(
                 "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_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(
                     "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);
-+
+        }
-178
+    }
     if let ::std::option::Option::Some(inner_15) = &input.sse_customer_key {
         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(
                 "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_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(
                     "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);
-+
+        }
-191
+    }
     if let ::std::option::Option::Some(inner_17) = &input.sse_customer_key_md5 {
         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(
                 "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_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(
                     "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);
-+
+        }
-204
+    }
     if let ::std::option::Option::Some(inner_19) = &input.copy_source_sse_customer_algorithm {
         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(
                 "copy_source_sse_customer_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", 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(
                     "copy_source_sse_customer_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", header_value);
-+
+        }
-217
+    }
     if let ::std::option::Option::Some(inner_21) = &input.copy_source_sse_customer_key {
         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(
                 "copy_source_sse_customer_key",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", 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(
                     "copy_source_sse_customer_key",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", header_value);
-+
+        }
-230
+    }
     if let ::std::option::Option::Some(inner_23) = &input.copy_source_sse_customer_key_md5 {
         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(
                 "copy_source_sse_customer_key_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", 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(
                     "copy_source_sse_customer_key_md5",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", header_value);
-+
+        }
-243
+    }
     if let ::std::option::Option::Some(inner_25) = &input.request_payer {
         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(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", 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(
                     "request_payer",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-256
+    }
     if let ::std::option::Option::Some(inner_27) = &input.expected_bucket_owner {
         let formatted_28 = inner_27.as_str();
         let header_value = formatted_28;
         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_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(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-269
+    }
     if let ::std::option::Option::Some(inner_29) = &input.expected_source_bucket_owner {
         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(
                 "expected_source_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-source-expected-bucket-owner", 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(
                     "expected_source_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
-+
+        }
-282
+    }
     Ok(builder)
-284
+}

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