Client Test

    })

}

pub fn ser_complete_snapshot_headers(

    input: &crate::operation::complete_snapshot::CompleteSnapshotInput,

    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.changed_blocks_count {

        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(

                    "changed_blocks_count",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("x-amz-ChangedBlocksCount", header_value);

        }

    if let ::std::option::Option::Some(inner_3) = &input.checksum_aggregation_method {

        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_aggregation_method",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("x-amz-Checksum-Aggregation-Method", header_value);

        }

    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-Checksum-Algorithm", header_value);

        }

    if let ::std::option::Option::Some(inner_7) = &input.checksum {

        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",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("x-amz-Checksum", header_value);

        }

    Ok(builder)

}

pub(crate) fn de_complete_snapshot(

    value: &[u8],

    mut builder: crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder,

) -> Result<crate::operation::complete_snapshot::builders::CompleteSnapshotOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {

    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();

    let tokens = &mut tokens_owned;

    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;

        output.build()

    })

}

pub fn ser_put_snapshot_block_headers(

    input: &crate::operation::put_snapshot_block::PutSnapshotBlockInput,

    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.checksum {

        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(

                    "checksum",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("x-amz-Checksum", header_value);

        }

    if let ::std::option::Option::Some(inner_3) = &input.progress {

        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(

                    "progress",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("x-amz-Progress", header_value);

        }

    if let ::std::option::Option::Some(inner_5) = &input.data_length {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);

        let formatted_6 = encoder.encode();

            let header_value = formatted_6;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "data_length",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("x-amz-Data-Length", header_value);

        }

    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-Checksum-Algorithm", header_value);

        }

    Ok(builder)

}

            .build()

            .map_err(crate::operation::required_header_collection_operation::RequiredHeaderCollectionOperationError::unhandled)?

    })

}

pub fn ser_required_header_collection_operation_headers(

    input: &crate::operation::required_header_collection_operation::RequiredHeaderCollectionOperationInput,

    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.required_header_list {

        for inner_2 in inner_1 {

            let formatted_3 = ::aws_smithy_http::header::quote_header_value(inner_2.as_str());

                let header_value = formatted_3;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "required_header_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-Required-List", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_4) = &input.required_header_set {

        for inner_5 in inner_4 {

            let formatted_6 = ::aws_smithy_http::header::quote_header_value(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(

                        "required_header_set",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-Required-Set", header_value);

            }

        }

            .map_err(crate::operation::get_storage::GetStorageError::unhandled)?

    })

}

pub fn ser_get_storage_headers(

    input: &crate::operation::get_storage::GetStorageInput,

    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.passcode {

        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(

                    "passcode",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("passcode", header_value);

        }

    Ok(builder)

}

pub(crate) fn de_get_storage(

    value: &[u8],

    mut builder: crate::operation::get_storage::builders::GetStorageOutputBuilder,

) -> Result<crate::operation::get_storage::builders::GetStorageOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {

    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();

    let tokens = &mut tokens_owned;

    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;

                uri_base(input, &mut uri)?;

                ::std::result::Result::Ok(builder.method("POST").uri(uri))

            }

            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;

            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");

            builder = _header_serialization_settings.set_default_header(

                builder,

                ::http::header::HeaderName::from_static("x-amz-target"),

                "QueryCompatService.Operation",

            );

            builder

        };

        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_operation::ser_operation_input(&input)?);

        if let Some(content_length) = body.content_length() {

            let content_length = content_length.to_string();

            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);

        }

        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

    }

}

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .operation()

            .set_message(::std::option::Option::Some("hello!".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{\"message\":\"hello!\"}",

            ::aws_smithy_protocol_test::MediaType::from("unknown"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/", "path was incorrect");

        let expected_headers = [("X-Foo", "Foo"), ("X-Foo-Abc", "Abc value"), ("X-Foo-Def", "Def value")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/HttpPrefixHeaders", "path was incorrect");

    }

    /// Test ID: RestJsonHttpPrefixHeadersAreNotPresent

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_http_prefix_headers_are_not_present_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .http_prefix_headers()

            .set_foo(::std::option::Option::Some("Foo".to_owned()))

            .set_foo_map(::std::option::Option::Some(::std::collections::HashMap::new()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("X-Foo", "Foo")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/HttpPrefixHeaders", "path was incorrect");

    }

    /// Adds headers by prefix

    /// Test ID: RestJsonHttpPrefixHeadersArePresent

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_http_prefix_headers_are_present_response() {

        let expected_output = crate::operation::http_prefix_headers::HttpPrefixHeadersOutput::builder()

            .set_foo(::std::option::Option::Some("Foo".to_owned()))

            .set_foo_map(::std::option::Option::Some({

                let mut ret = ::std::collections::HashMap::new();

                ret.insert("Abc".to_owned().to_ascii_lowercase(), "Abc value".to_owned());

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod null_and_empty_headers_client_test {

    /// Test ID: RestJsonNullAndEmptyHeaders

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_null_and_empty_headers_request() {

        let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let client = crate::Client::from_conf(config_builder.http_client(http_client).build());

        let result = client

            .null_and_empty_headers_client()

            .set_a(::std::option::Option::None)

            .set_b(::std::option::Option::Some("".to_owned()))

            .set_c(::std::option::Option::Some(vec![]))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/NullAndEmptyHeadersClient", "path was incorrect");

    }

}

        output.build()

    })

}

pub fn ser_http_payload_traits_headers(

    input: &crate::operation::http_payload_traits::HttpPayloadTraitsInput,

    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.foo {

        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(

                    "foo",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Foo", header_value);

        }

    Ok(builder)

}

        output.build()

    })

}

pub fn ser_http_payload_traits_with_media_type_headers(

    input: &crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput,

    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.foo {

        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(

                    "foo",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Foo", header_value);

        }

    Ok(builder)

}

        output.build()

    })

}

pub fn ser_http_prefix_headers_headers(

    input: &crate::operation::http_prefix_headers::HttpPrefixHeadersInput,

    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.foo {

        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(

                    "foo",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Foo", header_value);

        }

    if let ::std::option::Option::Some(inner_3) = &input.foo_map {

        {

            for (k, v) in inner_3 {

                use std::str::FromStr;

                let header_name = http::header::HeaderName::from_str(&format!("{}{}", "X-Foo-", &k)).map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "foo_map",

                        format!("`{k}` cannot be used as a header name: {err}"),

                    )

                })?;

        output.build()

    })

}

pub fn ser_input_and_output_with_headers_headers(

    input: &crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersInput,

    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.header_string {

        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(

                    "header_string",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-String", header_value);

        }

    if let ::std::option::Option::Some(inner_3) = &input.header_byte {

        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(

                    "header_byte",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Byte", header_value);

        }

    if let ::std::option::Option::Some(inner_5) = &input.header_short {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);

        let formatted_6 = encoder.encode();

            let header_value = formatted_6;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_short",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Short", header_value);

        }

    if let ::std::option::Option::Some(inner_7) = &input.header_integer {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_7);

        let formatted_8 = encoder.encode();

            let header_value = formatted_8;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_integer",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Integer", header_value);

        }

    if let ::std::option::Option::Some(inner_9) = &input.header_long {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_9);

        let formatted_10 = encoder.encode();

            let header_value = formatted_10;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_long",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Long", header_value);

        }

    if let ::std::option::Option::Some(inner_11) = &input.header_float {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_11);

        let formatted_12 = encoder.encode();

            let header_value = formatted_12;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_float",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Float", header_value);

        }

    if let ::std::option::Option::Some(inner_13) = &input.header_double {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);

        let formatted_14 = encoder.encode();

            let header_value = formatted_14;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_double",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Double", header_value);

        }

    if let ::std::option::Option::Some(inner_15) = &input.header_true_bool {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_15);

        let formatted_16 = encoder.encode();

            let header_value = formatted_16;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_true_bool",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Boolean1", header_value);

        }

    if let ::std::option::Option::Some(inner_17) = &input.header_false_bool {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);

        let formatted_18 = encoder.encode();

            let header_value = formatted_18;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_false_bool",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Boolean2", header_value);

        }

    if let ::std::option::Option::Some(inner_19) = &input.header_string_list {

        for inner_20 in inner_19 {

            let formatted_21 = ::aws_smithy_http::header::quote_header_value(inner_20.as_str());

                let header_value = formatted_21;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "header_string_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-StringList", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_22) = &input.header_string_set {

        for inner_23 in inner_22 {

            let formatted_24 = ::aws_smithy_http::header::quote_header_value(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(

                        "header_string_set",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-StringSet", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_25) = &input.header_integer_list {

        for inner_26 in inner_25 {

            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_26);

            let formatted_27 = encoder.encode();

                let header_value = formatted_27;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "header_integer_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-IntegerList", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_28) = &input.header_boolean_list {

        for inner_29 in inner_28 {

            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_29);

            let formatted_30 = encoder.encode();

                let header_value = formatted_30;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "header_boolean_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-BooleanList", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_31) = &input.header_timestamp_list {

        for inner_32 in inner_31 {

            let formatted_33 = inner_32.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;

                let header_value = formatted_33;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "header_timestamp_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-TimestampList", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_34) = &input.header_enum {

        let formatted_35 = inner_34.as_str();

            let header_value = formatted_35;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_enum",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-Enum", header_value);

        }

    if let ::std::option::Option::Some(inner_36) = &input.header_enum_list {

        for inner_37 in inner_36 {

            let formatted_38 = ::aws_smithy_http::header::quote_header_value(inner_37.as_str());

                let header_value = formatted_38;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "header_enum_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-EnumList", header_value);

            }

        }

    }

    if let ::std::option::Option::Some(inner_39) = &input.header_integer_enum {

        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_39);

        let formatted_40 = encoder.encode();

            let header_value = formatted_40;

            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                ::aws_smithy_types::error::operation::BuildError::invalid_field(

                    "header_integer_enum",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("X-IntegerEnum", header_value);

        }

    if let ::std::option::Option::Some(inner_41) = &input.header_integer_enum_list {

        for inner_42 in inner_41 {

            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_42);

            let formatted_43 = encoder.encode();

                let header_value = formatted_43;

                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {

                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

                        "header_integer_enum_list",

                        format!("`{}` cannot be used as a header value: {}", &header_value, err),

                    )

                })?;

                builder = builder.header("X-IntegerEnumList", header_value);

            }

        }

    })

}

pub fn ser_malformed_boolean_headers(

    input: &crate::operation::malformed_boolean::MalformedBooleanInput,

    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.boolean_in_header {

        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(

                    "boolean_in_header",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("booleanInHeader", header_value);

        }

    Ok(builder)

}

pub fn ser_malformed_boolean_input(

    input: &crate::operation::malformed_boolean::MalformedBooleanInput,

) -> Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {

    let mut out = String::new();

    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);

    crate::protocol_serde::shape_malformed_boolean_input::ser_malformed_boolean_input_input(&mut object, input)?;

    object.finish();

    })

}

pub fn ser_malformed_byte_headers(

    input: &crate::operation::malformed_byte::MalformedByteInput,

    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.byte_in_header {

        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(

                    "byte_in_header",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("byteInHeader", header_value);

        }

    Ok(builder)

}

pub fn ser_malformed_byte_input(

    input: &crate::operation::malformed_byte::MalformedByteInput,

) -> Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {

    let mut out = String::new();

    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);

    crate::protocol_serde::shape_malformed_byte_input::ser_malformed_byte_input_input(&mut object, input)?;

    object.finish();

    })

}

pub fn ser_malformed_double_headers(

    input: &crate::operation::malformed_double::MalformedDoubleInput,

    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.double_in_header {

        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(

                    "double_in_header",

                    format!("`{}` cannot be used as a header value: {}", &header_value, err),

                )

            })?;

            builder = builder.header("doubleInHeader", header_value);

        }