1#[allow(clippy::unnecessary_wraps)]
3pub fn de_put_object_http_error(
4 _response_status: u16,
5 _response_headers: &::aws_smithy_runtime_api::http::Headers,
6 _response_body: &[u8],
7) -> std::result::Result<crate::operation::put_object::PutObjectOutput, crate::operation::put_object::PutObjectError> {
8 #[allow(unused_mut)]
9 let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
10 .map_err(crate::operation::put_object::PutObjectError::unhandled)?;
11 generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
12 generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
13 let generic = generic_builder.build();
14 let error_code = match generic.code() {
15 Some(code) => code,
16 None => return Err(crate::operation::put_object::PutObjectError::unhandled(generic)),
17 };
18
19 let _error_message = generic.message().map(|msg| msg.to_owned());
20 Err(match error_code {
21 "EncryptionTypeMismatch" => crate::operation::put_object::PutObjectError::EncryptionTypeMismatch({
22 #[allow(unused_mut)]
23 let mut tmp = {
24 #[allow(unused_mut)]
25 let mut output = crate::types::error::builders::EncryptionTypeMismatchBuilder::default();
26 output = crate::protocol_serde::shape_encryption_type_mismatch::de_encryption_type_mismatch_xml_err(_response_body, output)
27 .map_err(crate::operation::put_object::PutObjectError::unhandled)?;
28 let output = output.meta(generic);
29 output.build()
30 };
31 if tmp.message.is_none() {
32 tmp.message = _error_message;
33 }
34 tmp
35 }),
36 "InvalidRequest" => crate::operation::put_object::PutObjectError::InvalidRequest({
37 #[allow(unused_mut)]
38 let mut tmp = {
39 #[allow(unused_mut)]
40 let mut output = crate::types::error::builders::InvalidRequestBuilder::default();
41 output = crate::protocol_serde::shape_invalid_request::de_invalid_request_xml_err(_response_body, output)
42 .map_err(crate::operation::put_object::PutObjectError::unhandled)?;
43 let output = output.meta(generic);
44 output.build()
45 };
46 if tmp.message.is_none() {
47 tmp.message = _error_message;
48 }
49 tmp
50 }),
51 "InvalidWriteOffset" => crate::operation::put_object::PutObjectError::InvalidWriteOffset({
52 #[allow(unused_mut)]
53 let mut tmp = {
54 #[allow(unused_mut)]
55 let mut output = crate::types::error::builders::InvalidWriteOffsetBuilder::default();
56 output = crate::protocol_serde::shape_invalid_write_offset::de_invalid_write_offset_xml_err(_response_body, output)
57 .map_err(crate::operation::put_object::PutObjectError::unhandled)?;
58 let output = output.meta(generic);
59 output.build()
60 };
61 if tmp.message.is_none() {
62 tmp.message = _error_message;
63 }
64 tmp
65 }),
66 "TooManyParts" => crate::operation::put_object::PutObjectError::TooManyParts({
67 #[allow(unused_mut)]
68 let mut tmp = {
69 #[allow(unused_mut)]
70 let mut output = crate::types::error::builders::TooManyPartsBuilder::default();
71 output = crate::protocol_serde::shape_too_many_parts::de_too_many_parts_xml_err(_response_body, output)
72 .map_err(crate::operation::put_object::PutObjectError::unhandled)?;
73 let output = output.meta(generic);
74 output.build()
75 };
76 if tmp.message.is_none() {
77 tmp.message = _error_message;
78 }
79 tmp
80 }),
81 _ => crate::operation::put_object::PutObjectError::generic(generic),
82 })
83}
84
85#[allow(clippy::unnecessary_wraps)]
86pub fn de_put_object_http_response(
87 _response_status: u16,
88 _response_headers: &::aws_smithy_runtime_api::http::Headers,
89 _response_body: &[u8],
90) -> std::result::Result<crate::operation::put_object::PutObjectOutput, crate::operation::put_object::PutObjectError> {
91 Ok({
92 #[allow(unused_mut)]
93 let mut output = crate::operation::put_object::builders::PutObjectOutputBuilder::default();
94 output = output.set_bucket_key_enabled(
95 crate::protocol_serde::shape_put_object_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
96 crate::operation::put_object::PutObjectError::unhandled(
97 "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
98 )
99 })?,
100 );
101 output = output.set_checksum_crc32(
102 crate::protocol_serde::shape_put_object_output::de_checksum_crc32_header(_response_headers).map_err(|_| {
103 crate::operation::put_object::PutObjectError::unhandled("Failed to parse ChecksumCRC32 from header `x-amz-checksum-crc32")
104 })?,
105 );
106 output = output.set_checksum_crc32_c(
107 crate::protocol_serde::shape_put_object_output::de_checksum_crc32_c_header(_response_headers).map_err(|_| {
108 crate::operation::put_object::PutObjectError::unhandled("Failed to parse ChecksumCRC32C from header `x-amz-checksum-crc32c")
109 })?,
110 );
111 output = output.set_checksum_crc64_nvme(
112 crate::protocol_serde::shape_put_object_output::de_checksum_crc64_nvme_header(_response_headers).map_err(|_| {
113 crate::operation::put_object::PutObjectError::unhandled("Failed to parse ChecksumCRC64NVME from header `x-amz-checksum-crc64nvme")
114 })?,
115 );
116 output = output.set_checksum_sha1(
117 crate::protocol_serde::shape_put_object_output::de_checksum_sha1_header(_response_headers).map_err(|_| {
118 crate::operation::put_object::PutObjectError::unhandled("Failed to parse ChecksumSHA1 from header `x-amz-checksum-sha1")
119 })?,
120 );
121 output = output.set_checksum_sha256(
122 crate::protocol_serde::shape_put_object_output::de_checksum_sha256_header(_response_headers).map_err(|_| {
123 crate::operation::put_object::PutObjectError::unhandled("Failed to parse ChecksumSHA256 from header `x-amz-checksum-sha256")
124 })?,
125 );
126 output = output.set_checksum_type(
127 crate::protocol_serde::shape_put_object_output::de_checksum_type_header(_response_headers).map_err(|_| {
128 crate::operation::put_object::PutObjectError::unhandled("Failed to parse ChecksumType from header `x-amz-checksum-type")
129 })?,
130 );
131 output = output.set_e_tag(
132 crate::protocol_serde::shape_put_object_output::de_e_tag_header(_response_headers)
133 .map_err(|_| crate::operation::put_object::PutObjectError::unhandled("Failed to parse ETag from header `ETag"))?,
134 );
135 output = output.set_expiration(
136 crate::protocol_serde::shape_put_object_output::de_expiration_header(_response_headers)
137 .map_err(|_| crate::operation::put_object::PutObjectError::unhandled("Failed to parse Expiration from header `x-amz-expiration"))?,
138 );
139 output = output.set_request_charged(
140 crate::protocol_serde::shape_put_object_output::de_request_charged_header(_response_headers).map_err(|_| {
141 crate::operation::put_object::PutObjectError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
142 })?,
143 );
144 output = output.set_sse_customer_algorithm(
145 crate::protocol_serde::shape_put_object_output::de_sse_customer_algorithm_header(_response_headers).map_err(|_| {
146 crate::operation::put_object::PutObjectError::unhandled(
147 "Failed to parse SSECustomerAlgorithm from header `x-amz-server-side-encryption-customer-algorithm",
148 )
149 })?,
150 );
151 output = output.set_sse_customer_key_md5(
152 crate::protocol_serde::shape_put_object_output::de_sse_customer_key_md5_header(_response_headers).map_err(|_| {
153 crate::operation::put_object::PutObjectError::unhandled(
154 "Failed to parse SSECustomerKeyMD5 from header `x-amz-server-side-encryption-customer-key-MD5",
155 )
156 })?,
157 );
158 output = output.set_ssekms_encryption_context(
159 crate::protocol_serde::shape_put_object_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
160 crate::operation::put_object::PutObjectError::unhandled(
161 "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
162 )
163 })?,
164 );
165 output = output.set_ssekms_key_id(
166 crate::protocol_serde::shape_put_object_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
167 crate::operation::put_object::PutObjectError::unhandled(
168 "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
169 )
170 })?,
171 );
172 output = output.set_server_side_encryption(
173 crate::protocol_serde::shape_put_object_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
174 crate::operation::put_object::PutObjectError::unhandled(
175 "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
176 )
177 })?,
178 );
179 output = output.set_size(
180 crate::protocol_serde::shape_put_object_output::de_size_header(_response_headers)
181 .map_err(|_| crate::operation::put_object::PutObjectError::unhandled("Failed to parse Size from header `x-amz-object-size"))?,
182 );
183 output = output.set_version_id(
184 crate::protocol_serde::shape_put_object_output::de_version_id_header(_response_headers)
185 .map_err(|_| crate::operation::put_object::PutObjectError::unhandled("Failed to parse VersionId from header `x-amz-version-id"))?,
186 );
187 output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
188 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
189 output.build()
190 })
191}
192
193pub fn ser_put_object_headers(
194 input: &crate::operation::put_object::PutObjectInput,
195 mut builder: ::http::request::Builder,
196) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
197 if let ::std::option::Option::Some(inner_1) = &input.acl {
198 let formatted_2 = inner_1.as_str();
199 let header_value = formatted_2;
200 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
201 ::aws_smithy_types::error::operation::BuildError::invalid_field(
202 "acl",
203 format!("`{}` cannot be used as a header value: {}", &header_value, err),
204 )
205 })?;
206 builder = builder.header("x-amz-acl", header_value);
207 }
208 if let ::std::option::Option::Some(inner_3) = &input.cache_control {
209 let formatted_4 = inner_3.as_str();
210 let header_value = formatted_4;
211 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
212 ::aws_smithy_types::error::operation::BuildError::invalid_field(
213 "cache_control",
214 format!("`{}` cannot be used as a header value: {}", &header_value, err),
215 )
216 })?;
217 builder = builder.header("Cache-Control", header_value);
218 }
219 if let ::std::option::Option::Some(inner_5) = &input.content_disposition {
220 let formatted_6 = inner_5.as_str();
221 let header_value = formatted_6;
222 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
223 ::aws_smithy_types::error::operation::BuildError::invalid_field(
224 "content_disposition",
225 format!("`{}` cannot be used as a header value: {}", &header_value, err),
226 )
227 })?;
228 builder = builder.header("Content-Disposition", header_value);
229 }
230 if let ::std::option::Option::Some(inner_7) = &input.content_encoding {
231 let formatted_8 = inner_7.as_str();
232 let header_value = formatted_8;
233 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
234 ::aws_smithy_types::error::operation::BuildError::invalid_field(
235 "content_encoding",
236 format!("`{}` cannot be used as a header value: {}", &header_value, err),
237 )
238 })?;
239 builder = builder.header("Content-Encoding", header_value);
240 }
241 if let ::std::option::Option::Some(inner_9) = &input.content_language {
242 let formatted_10 = inner_9.as_str();
243 let header_value = formatted_10;
244 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
245 ::aws_smithy_types::error::operation::BuildError::invalid_field(
246 "content_language",
247 format!("`{}` cannot be used as a header value: {}", &header_value, err),
248 )
249 })?;
250 builder = builder.header("Content-Language", header_value);
251 }
252 if let ::std::option::Option::Some(inner_11) = &input.content_length {
253 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_11);
254 let formatted_12 = encoder.encode();
255 let header_value = formatted_12;
256 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
257 ::aws_smithy_types::error::operation::BuildError::invalid_field(
258 "content_length",
259 format!("`{}` cannot be used as a header value: {}", &header_value, err),
260 )
261 })?;
262 builder = builder.header("Content-Length", header_value);
263 }
264 if let ::std::option::Option::Some(inner_13) = &input.content_md5 {
265 let formatted_14 = inner_13.as_str();
266 let header_value = formatted_14;
267 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
268 ::aws_smithy_types::error::operation::BuildError::invalid_field(
269 "content_md5",
270 format!("`{}` cannot be used as a header value: {}", &header_value, err),
271 )
272 })?;
273 builder = builder.header("Content-MD5", header_value);
274 }
275 if let ::std::option::Option::Some(inner_15) = &input.content_type {
276 let formatted_16 = inner_15.as_str();
277 let header_value = formatted_16;
278 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
279 ::aws_smithy_types::error::operation::BuildError::invalid_field(
280 "content_type",
281 format!("`{}` cannot be used as a header value: {}", &header_value, err),
282 )
283 })?;
284 builder = builder.header("Content-Type", header_value);
285 }
286 if let ::std::option::Option::Some(inner_17) = &input.checksum_algorithm {
287 let formatted_18 = inner_17.as_str();
288 let header_value = formatted_18;
289 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
290 ::aws_smithy_types::error::operation::BuildError::invalid_field(
291 "checksum_algorithm",
292 format!("`{}` cannot be used as a header value: {}", &header_value, err),
293 )
294 })?;
295 builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
296 }
297 if let ::std::option::Option::Some(inner_19) = &input.checksum_crc32 {
298 let formatted_20 = inner_19.as_str();
299 let header_value = formatted_20;
300 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
301 ::aws_smithy_types::error::operation::BuildError::invalid_field(
302 "checksum_crc32",
303 format!("`{}` cannot be used as a header value: {}", &header_value, err),
304 )
305 })?;
306 builder = builder.header("x-amz-checksum-crc32", header_value);
307 }
308 if let ::std::option::Option::Some(inner_21) = &input.checksum_crc32_c {
309 let formatted_22 = inner_21.as_str();
310 let header_value = formatted_22;
311 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
312 ::aws_smithy_types::error::operation::BuildError::invalid_field(
313 "checksum_crc32_c",
314 format!("`{}` cannot be used as a header value: {}", &header_value, err),
315 )
316 })?;
317 builder = builder.header("x-amz-checksum-crc32c", header_value);
318 }
319 if let ::std::option::Option::Some(inner_23) = &input.checksum_crc64_nvme {
320 let formatted_24 = inner_23.as_str();
321 let header_value = formatted_24;
322 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
323 ::aws_smithy_types::error::operation::BuildError::invalid_field(
324 "checksum_crc64_nvme",
325 format!("`{}` cannot be used as a header value: {}", &header_value, err),
326 )
327 })?;
328 builder = builder.header("x-amz-checksum-crc64nvme", header_value);
329 }
330 if let ::std::option::Option::Some(inner_25) = &input.checksum_sha1 {
331 let formatted_26 = inner_25.as_str();
332 let header_value = formatted_26;
333 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
334 ::aws_smithy_types::error::operation::BuildError::invalid_field(
335 "checksum_sha1",
336 format!("`{}` cannot be used as a header value: {}", &header_value, err),
337 )
338 })?;
339 builder = builder.header("x-amz-checksum-sha1", header_value);
340 }
341 if let ::std::option::Option::Some(inner_27) = &input.checksum_sha256 {
342 let formatted_28 = inner_27.as_str();
343 let header_value = formatted_28;
344 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
345 ::aws_smithy_types::error::operation::BuildError::invalid_field(
346 "checksum_sha256",
347 format!("`{}` cannot be used as a header value: {}", &header_value, err),
348 )
349 })?;
350 builder = builder.header("x-amz-checksum-sha256", header_value);
351 }
352 if let ::std::option::Option::Some(inner_29) = &input.expires {
353 let formatted_30 = inner_29.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
354 let header_value = formatted_30;
355 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
356 ::aws_smithy_types::error::operation::BuildError::invalid_field(
357 "expires",
358 format!("`{}` cannot be used as a header value: {}", &header_value, err),
359 )
360 })?;
361 builder = builder.header("Expires", header_value);
362 }
363 if let ::std::option::Option::Some(inner_31) = &input.if_match {
364 let formatted_32 = inner_31.as_str();
365 let header_value = formatted_32;
366 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
367 ::aws_smithy_types::error::operation::BuildError::invalid_field(
368 "if_match",
369 format!("`{}` cannot be used as a header value: {}", &header_value, err),
370 )
371 })?;
372 builder = builder.header("If-Match", header_value);
373 }
374 if let ::std::option::Option::Some(inner_33) = &input.if_none_match {
375 let formatted_34 = inner_33.as_str();
376 let header_value = formatted_34;
377 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
378 ::aws_smithy_types::error::operation::BuildError::invalid_field(
379 "if_none_match",
380 format!("`{}` cannot be used as a header value: {}", &header_value, err),
381 )
382 })?;
383 builder = builder.header("If-None-Match", header_value);
384 }
385 if let ::std::option::Option::Some(inner_35) = &input.grant_full_control {
386 let formatted_36 = inner_35.as_str();
387 let header_value = formatted_36;
388 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
389 ::aws_smithy_types::error::operation::BuildError::invalid_field(
390 "grant_full_control",
391 format!("`{}` cannot be used as a header value: {}", &header_value, err),
392 )
393 })?;
394 builder = builder.header("x-amz-grant-full-control", header_value);
395 }
396 if let ::std::option::Option::Some(inner_37) = &input.grant_read {
397 let formatted_38 = inner_37.as_str();
398 let header_value = formatted_38;
399 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
400 ::aws_smithy_types::error::operation::BuildError::invalid_field(
401 "grant_read",
402 format!("`{}` cannot be used as a header value: {}", &header_value, err),
403 )
404 })?;
405 builder = builder.header("x-amz-grant-read", header_value);
406 }
407 if let ::std::option::Option::Some(inner_39) = &input.grant_read_acp {
408 let formatted_40 = inner_39.as_str();
409 let header_value = formatted_40;
410 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
411 ::aws_smithy_types::error::operation::BuildError::invalid_field(
412 "grant_read_acp",
413 format!("`{}` cannot be used as a header value: {}", &header_value, err),
414 )
415 })?;
416 builder = builder.header("x-amz-grant-read-acp", header_value);
417 }
418 if let ::std::option::Option::Some(inner_41) = &input.grant_write_acp {
419 let formatted_42 = inner_41.as_str();
420 let header_value = formatted_42;
421 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
422 ::aws_smithy_types::error::operation::BuildError::invalid_field(
423 "grant_write_acp",
424 format!("`{}` cannot be used as a header value: {}", &header_value, err),
425 )
426 })?;
427 builder = builder.header("x-amz-grant-write-acp", header_value);
428 }
429 if let ::std::option::Option::Some(inner_43) = &input.write_offset_bytes {
430 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_43);
431 let formatted_44 = encoder.encode();
432 let header_value = formatted_44;
433 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
434 ::aws_smithy_types::error::operation::BuildError::invalid_field(
435 "write_offset_bytes",
436 format!("`{}` cannot be used as a header value: {}", &header_value, err),
437 )
438 })?;
439 builder = builder.header("x-amz-write-offset-bytes", header_value);
440 }
441 if let ::std::option::Option::Some(inner_45) = &input.server_side_encryption {
442 let formatted_46 = inner_45.as_str();
443 let header_value = formatted_46;
444 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
445 ::aws_smithy_types::error::operation::BuildError::invalid_field(
446 "server_side_encryption",
447 format!("`{}` cannot be used as a header value: {}", &header_value, err),
448 )
449 })?;
450 builder = builder.header("x-amz-server-side-encryption", header_value);
451 }
452 if let ::std::option::Option::Some(inner_47) = &input.storage_class {
453 let formatted_48 = inner_47.as_str();
454 let header_value = formatted_48;
455 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
456 ::aws_smithy_types::error::operation::BuildError::invalid_field(
457 "storage_class",
458 format!("`{}` cannot be used as a header value: {}", &header_value, err),
459 )
460 })?;
461 builder = builder.header("x-amz-storage-class", header_value);
462 }
463 if let ::std::option::Option::Some(inner_49) = &input.website_redirect_location {
464 let formatted_50 = inner_49.as_str();
465 let header_value = formatted_50;
466 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
467 ::aws_smithy_types::error::operation::BuildError::invalid_field(
468 "website_redirect_location",
469 format!("`{}` cannot be used as a header value: {}", &header_value, err),
470 )
471 })?;
472 builder = builder.header("x-amz-website-redirect-location", header_value);
473 }
474 if let ::std::option::Option::Some(inner_51) = &input.sse_customer_algorithm {
475 let formatted_52 = inner_51.as_str();
476 let header_value = formatted_52;
477 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
478 ::aws_smithy_types::error::operation::BuildError::invalid_field(
479 "sse_customer_algorithm",
480 format!("`{}` cannot be used as a header value: {}", &header_value, err),
481 )
482 })?;
483 builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
484 }
485 if let ::std::option::Option::Some(inner_53) = &input.sse_customer_key {
486 let formatted_54 = inner_53.as_str();
487 let header_value = formatted_54;
488 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
489 ::aws_smithy_types::error::operation::BuildError::invalid_field(
490 "sse_customer_key",
491 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
492 )
493 })?;
494 builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
495 }
496 if let ::std::option::Option::Some(inner_55) = &input.sse_customer_key_md5 {
497 let formatted_56 = inner_55.as_str();
498 let header_value = formatted_56;
499 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
500 ::aws_smithy_types::error::operation::BuildError::invalid_field(
501 "sse_customer_key_md5",
502 format!("`{}` cannot be used as a header value: {}", &header_value, err),
503 )
504 })?;
505 builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
506 }
507 if let ::std::option::Option::Some(inner_57) = &input.ssekms_key_id {
508 let formatted_58 = inner_57.as_str();
509 let header_value = formatted_58;
510 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
511 ::aws_smithy_types::error::operation::BuildError::invalid_field(
512 "ssekms_key_id",
513 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
514 )
515 })?;
516 builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
517 }
518 if let ::std::option::Option::Some(inner_59) = &input.ssekms_encryption_context {
519 let formatted_60 = inner_59.as_str();
520 let header_value = formatted_60;
521 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
522 ::aws_smithy_types::error::operation::BuildError::invalid_field(
523 "ssekms_encryption_context",
524 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
525 )
526 })?;
527 builder = builder.header("x-amz-server-side-encryption-context", header_value);
528 }
529 if let ::std::option::Option::Some(inner_61) = &input.bucket_key_enabled {
530 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_61);
531 let formatted_62 = encoder.encode();
532 let header_value = formatted_62;
533 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
534 ::aws_smithy_types::error::operation::BuildError::invalid_field(
535 "bucket_key_enabled",
536 format!("`{}` cannot be used as a header value: {}", &header_value, err),
537 )
538 })?;
539 builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
540 }
541 if let ::std::option::Option::Some(inner_63) = &input.request_payer {
542 let formatted_64 = inner_63.as_str();
543 let header_value = formatted_64;
544 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
545 ::aws_smithy_types::error::operation::BuildError::invalid_field(
546 "request_payer",
547 format!("`{}` cannot be used as a header value: {}", &header_value, err),
548 )
549 })?;
550 builder = builder.header("x-amz-request-payer", header_value);
551 }
552 if let ::std::option::Option::Some(inner_65) = &input.tagging {
553 let formatted_66 = inner_65.as_str();
554 let header_value = formatted_66;
555 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
556 ::aws_smithy_types::error::operation::BuildError::invalid_field(
557 "tagging",
558 format!("`{}` cannot be used as a header value: {}", &header_value, err),
559 )
560 })?;
561 builder = builder.header("x-amz-tagging", header_value);
562 }
563 if let ::std::option::Option::Some(inner_67) = &input.object_lock_mode {
564 let formatted_68 = inner_67.as_str();
565 let header_value = formatted_68;
566 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
567 ::aws_smithy_types::error::operation::BuildError::invalid_field(
568 "object_lock_mode",
569 format!("`{}` cannot be used as a header value: {}", &header_value, err),
570 )
571 })?;
572 builder = builder.header("x-amz-object-lock-mode", header_value);
573 }
574 if let ::std::option::Option::Some(inner_69) = &input.object_lock_retain_until_date {
575 let formatted_70 = inner_69.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
576 let header_value = formatted_70;
577 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
578 ::aws_smithy_types::error::operation::BuildError::invalid_field(
579 "object_lock_retain_until_date",
580 format!("`{}` cannot be used as a header value: {}", &header_value, err),
581 )
582 })?;
583 builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
584 }
585 if let ::std::option::Option::Some(inner_71) = &input.object_lock_legal_hold_status {
586 let formatted_72 = inner_71.as_str();
587 let header_value = formatted_72;
588 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
589 ::aws_smithy_types::error::operation::BuildError::invalid_field(
590 "object_lock_legal_hold_status",
591 format!("`{}` cannot be used as a header value: {}", &header_value, err),
592 )
593 })?;
594 builder = builder.header("x-amz-object-lock-legal-hold", header_value);
595 }
596 if let ::std::option::Option::Some(inner_73) = &input.expected_bucket_owner {
597 let formatted_74 = inner_73.as_str();
598 let header_value = formatted_74;
599 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
600 ::aws_smithy_types::error::operation::BuildError::invalid_field(
601 "expected_bucket_owner",
602 format!("`{}` cannot be used as a header value: {}", &header_value, err),
603 )
604 })?;
605 builder = builder.header("x-amz-expected-bucket-owner", header_value);
606 }
607 if let ::std::option::Option::Some(inner_75) = &input.metadata {
608 {
609 for (k, v) in inner_75 {
610 use std::str::FromStr;
611 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
612 ::aws_smithy_types::error::operation::BuildError::invalid_field(
613 "metadata",
614 format!("`{k}` cannot be used as a header name: {err}"),
615 )
616 })?;
617 let header_value = v.as_str();
618 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
619 ::aws_smithy_types::error::operation::BuildError::invalid_field(
620 "metadata",
621 format!("`{}` cannot be used as a header value: {}", v, err),
622 )
623 })?;
624 builder = builder.header(header_name, header_value);
625 }
626 }
627 }
628 Ok(builder)
629}