Client Test

Client Test

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_endpoint_with_host_label_header_operation.rs

@@ -7,7 +51,51 @@
   27     27   
    Ok({
   28     28   
        #[allow(unused_mut)]
   29     29   
        let mut output =
   30     30   
            crate::operation::endpoint_with_host_label_header_operation::builders::EndpointWithHostLabelHeaderOperationOutputBuilder::default();
   31     31   
        output.build()
   32     32   
    })
   33     33   
}
   34     34   
   35     35   
pub fn ser_endpoint_with_host_label_header_operation_headers(
   36     36   
    input: &crate::operation::endpoint_with_host_label_header_operation::EndpointWithHostLabelHeaderOperationInput,
   37         -
    mut builder: ::http::request::Builder,
   38         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          37  +
    mut builder: ::http_1x::request::Builder,
          38  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   39     39   
    if let ::std::option::Option::Some(inner_1) = &input.account_id {
   40     40   
        let formatted_2 = inner_1.as_str();
   41     41   
        let header_value = formatted_2;
   42         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          42  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   43     43   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   44     44   
                "account_id",
   45     45   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   46     46   
            )
   47     47   
        })?;
   48     48   
        builder = builder.header("X-Amz-Account-Id", header_value);
   49     49   
    }
   50     50   
    Ok(builder)
   51     51   
}

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_http_empty_prefix_headers.rs

@@ -20,20 +85,85 @@
   40     40   
                    "Failed to parse specificHeader from header `hello",
   41     41   
                )
   42     42   
            })?,
   43     43   
        );
   44     44   
        output.build()
   45     45   
    })
   46     46   
}
   47     47   
   48     48   
pub fn ser_http_empty_prefix_headers_headers(
   49     49   
    input: &crate::operation::http_empty_prefix_headers::HttpEmptyPrefixHeadersInput,
   50         -
    mut builder: ::http::request::Builder,
   51         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          50  +
    mut builder: ::http_1x::request::Builder,
          51  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   52     52   
    if let ::std::option::Option::Some(inner_1) = &input.specific_header {
   53     53   
        let formatted_2 = inner_1.as_str();
   54     54   
        let header_value = formatted_2;
   55         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          55  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   56     56   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   57     57   
                "specific_header",
   58     58   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   59     59   
            )
   60     60   
        })?;
   61     61   
        builder = builder.header("hello", header_value);
   62     62   
    }
   63     63   
    if let ::std::option::Option::Some(inner_3) = &input.prefix_headers {
   64     64   
        {
   65     65   
            for (k, v) in inner_3 {
   66     66   
                use std::str::FromStr;
   67         -
                let header_name = http::header::HeaderName::from_str(&format!("{}{}", "", &k)).map_err(|err| {
          67  +
                let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "", &k)).map_err(|err| {
   68     68   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   69     69   
                        "prefix_headers",
   70     70   
                        format!("`{k}` cannot be used as a header name: {err}"),
   71     71   
                    )
   72     72   
                })?;
   73     73   
                let header_value = v.as_str();
   74         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          74  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   75     75   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   76     76   
                        "prefix_headers",
   77     77   
                        format!("`{v}` cannot be used as a header value: {err}"),
   78     78   
                    )
   79     79   
                })?;
   80     80   
                builder = builder.header(header_name, header_value);
   81     81   
            }
   82     82   
        }
   83     83   
    }
   84     84   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_http_payload_traits.rs

@@ -7,7 +51,51 @@
   27     27   
        output = output.set_foo(
   28     28   
            crate::protocol_serde::shape_http_payload_traits_output::de_foo_header(_response_headers)
   29     29   
                .map_err(|_| crate::operation::http_payload_traits::HttpPayloadTraitsError::unhandled("Failed to parse foo from header `X-Foo"))?,
   30     30   
        );
   31     31   
        output.build()
   32     32   
    })
   33     33   
}
   34     34   
   35     35   
pub fn ser_http_payload_traits_headers(
   36     36   
    input: &crate::operation::http_payload_traits::HttpPayloadTraitsInput,
   37         -
    mut builder: ::http::request::Builder,
   38         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          37  +
    mut builder: ::http_1x::request::Builder,
          38  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   39     39   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   40     40   
        let formatted_2 = inner_1.as_str();
   41     41   
        let header_value = formatted_2;
   42         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          42  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   43     43   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   44     44   
                "foo",
   45     45   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   46     46   
            )
   47     47   
        })?;
   48     48   
        builder = builder.header("X-Foo", header_value);
   49     49   
    }
   50     50   
    Ok(builder)
   51     51   
}

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_http_payload_traits_with_media_type.rs

@@ -16,16 +60,60 @@
   36     36   
                    "Failed to parse foo from header `X-Foo",
   37     37   
                )
   38     38   
            })?,
   39     39   
        );
   40     40   
        output.build()
   41     41   
    })
   42     42   
}
   43     43   
   44     44   
pub fn ser_http_payload_traits_with_media_type_headers(
   45     45   
    input: &crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput,
   46         -
    mut builder: ::http::request::Builder,
   47         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          46  +
    mut builder: ::http_1x::request::Builder,
          47  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   48     48   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   49     49   
        let formatted_2 = inner_1.as_str();
   50     50   
        let header_value = formatted_2;
   51         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          51  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   52     52   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   53     53   
                "foo",
   54     54   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   55     55   
            )
   56     56   
        })?;
   57     57   
        builder = builder.header("X-Foo", header_value);
   58     58   
    }
   59     59   
    Ok(builder)
   60     60   
}

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_http_prefix_headers.rs

@@ -11,11 +76,76 @@
   31     31   
            crate::protocol_serde::shape_http_prefix_headers_output::de_foo_map_prefix_header(_response_headers).map_err(|_| {
   32     32   
                crate::operation::http_prefix_headers::HttpPrefixHeadersError::unhandled("Failed to parse fooMap from prefix header `x-foo-")
   33     33   
            })?,
   34     34   
        );
   35     35   
        output.build()
   36     36   
    })
   37     37   
}
   38     38   
   39     39   
pub fn ser_http_prefix_headers_headers(
   40     40   
    input: &crate::operation::http_prefix_headers::HttpPrefixHeadersInput,
   41         -
    mut builder: ::http::request::Builder,
   42         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          41  +
    mut builder: ::http_1x::request::Builder,
          42  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   43     43   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   44     44   
        let formatted_2 = inner_1.as_str();
   45     45   
        let header_value = formatted_2;
   46         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          46  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   47     47   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   48     48   
                "foo",
   49     49   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   50     50   
            )
   51     51   
        })?;
   52     52   
        builder = builder.header("x-foo", header_value);
   53     53   
    }
   54     54   
    if let ::std::option::Option::Some(inner_3) = &input.foo_map {
   55     55   
        {
   56     56   
            for (k, v) in inner_3 {
   57     57   
                use std::str::FromStr;
   58         -
                let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-foo-", &k)).map_err(|err| {
          58  +
                let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-foo-", &k)).map_err(|err| {
   59     59   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   60     60   
                        "foo_map",
   61     61   
                        format!("`{k}` cannot be used as a header name: {err}"),
   62     62   
                    )
   63     63   
                })?;
   64     64   
                let header_value = v.as_str();
   65         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          65  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   66     66   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   67     67   
                        "foo_map",
   68     68   
                        format!("`{v}` cannot be used as a header value: {err}"),
   69     69   
                    )
   70     70   
                })?;
   71     71   
                builder = builder.header(header_name, header_value);
   72     72   
            }
   73     73   
        }
   74     74   
    }
   75     75   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_input_and_output_with_headers.rs

@@ -120,120 +381,381 @@
  140    140   
                    "Failed to parse headerTrueBool from header `X-Boolean1",
  141    141   
                )
  142    142   
            })?,
  143    143   
        );
  144    144   
        output.build()
  145    145   
    })
  146    146   
}
  147    147   
  148    148   
pub fn ser_input_and_output_with_headers_headers(
  149    149   
    input: &crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersInput,
  150         -
    mut builder: ::http::request::Builder,
  151         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         150  +
    mut builder: ::http_1x::request::Builder,
         151  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  152    152   
    if let ::std::option::Option::Some(inner_1) = &input.header_string {
  153    153   
        let formatted_2 = inner_1.as_str();
  154    154   
        let header_value = formatted_2;
  155         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         155  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  156    156   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  157    157   
                "header_string",
  158    158   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  159    159   
            )
  160    160   
        })?;
  161    161   
        builder = builder.header("X-String", header_value);
  162    162   
    }
  163    163   
    if let ::std::option::Option::Some(inner_3) = &input.header_byte {
  164    164   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
  165    165   
        let formatted_4 = encoder.encode();
  166    166   
        let header_value = formatted_4;
  167         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         167  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  168    168   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  169    169   
                "header_byte",
  170    170   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  171    171   
            )
  172    172   
        })?;
  173    173   
        builder = builder.header("X-Byte", header_value);
  174    174   
    }
  175    175   
    if let ::std::option::Option::Some(inner_5) = &input.header_short {
  176    176   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
  177    177   
        let formatted_6 = encoder.encode();
  178    178   
        let header_value = formatted_6;
  179         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         179  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  180    180   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  181    181   
                "header_short",
  182    182   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  183    183   
            )
  184    184   
        })?;
  185    185   
        builder = builder.header("X-Short", header_value);
  186    186   
    }
  187    187   
    if let ::std::option::Option::Some(inner_7) = &input.header_integer {
  188    188   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_7);
  189    189   
        let formatted_8 = encoder.encode();
  190    190   
        let header_value = formatted_8;
  191         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         191  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  192    192   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  193    193   
                "header_integer",
  194    194   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  195    195   
            )
  196    196   
        })?;
  197    197   
        builder = builder.header("X-Integer", header_value);
  198    198   
    }
  199    199   
    if let ::std::option::Option::Some(inner_9) = &input.header_long {
  200    200   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_9);
  201    201   
        let formatted_10 = encoder.encode();
  202    202   
        let header_value = formatted_10;
  203         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         203  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  204    204   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  205    205   
                "header_long",
  206    206   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  207    207   
            )
  208    208   
        })?;
  209    209   
        builder = builder.header("X-Long", header_value);
  210    210   
    }
  211    211   
    if let ::std::option::Option::Some(inner_11) = &input.header_float {
  212    212   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_11);
  213    213   
        let formatted_12 = encoder.encode();
  214    214   
        let header_value = formatted_12;
  215         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         215  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  216    216   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  217    217   
                "header_float",
  218    218   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  219    219   
            )
  220    220   
        })?;
  221    221   
        builder = builder.header("X-Float", header_value);
  222    222   
    }
  223    223   
    if let ::std::option::Option::Some(inner_13) = &input.header_double {
  224    224   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
  225    225   
        let formatted_14 = encoder.encode();
  226    226   
        let header_value = formatted_14;
  227         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         227  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  228    228   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  229    229   
                "header_double",
  230    230   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  231    231   
            )
  232    232   
        })?;
  233    233   
        builder = builder.header("X-Double", header_value);
  234    234   
    }
  235    235   
    if let ::std::option::Option::Some(inner_15) = &input.header_true_bool {
  236    236   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_15);
  237    237   
        let formatted_16 = encoder.encode();
  238    238   
        let header_value = formatted_16;
  239         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         239  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  240    240   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  241    241   
                "header_true_bool",
  242    242   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  243    243   
            )
  244    244   
        })?;
  245    245   
        builder = builder.header("X-Boolean1", header_value);
  246    246   
    }
  247    247   
    if let ::std::option::Option::Some(inner_17) = &input.header_false_bool {
  248    248   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);
  249    249   
        let formatted_18 = encoder.encode();
  250    250   
        let header_value = formatted_18;
  251         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         251  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  252    252   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  253    253   
                "header_false_bool",
  254    254   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  255    255   
            )
  256    256   
        })?;
  257    257   
        builder = builder.header("X-Boolean2", header_value);
  258    258   
    }
  259    259   
    if let ::std::option::Option::Some(inner_19) = &input.header_string_list {
  260    260   
        // Empty vec in header is serialized as an empty string
  261    261   
        if inner_19.is_empty() {
  262    262   
            builder = builder.header("X-StringList", "");
  263    263   
        } else {
  264    264   
            for inner_20 in inner_19 {
  265    265   
                let formatted_21 = ::aws_smithy_http::header::quote_header_value(inner_20.as_str());
  266    266   
                let header_value = formatted_21;
  267         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         267  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  268    268   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  269    269   
                        "header_string_list",
  270    270   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  271    271   
                    )
  272    272   
                })?;
  273    273   
                builder = builder.header("X-StringList", header_value);
  274    274   
            }
  275    275   
        }
  276    276   
    }
  277    277   
    if let ::std::option::Option::Some(inner_22) = &input.header_string_set {
  278    278   
        // Empty vec in header is serialized as an empty string
  279    279   
        if inner_22.is_empty() {
  280    280   
            builder = builder.header("X-StringSet", "");
  281    281   
        } else {
  282    282   
            for inner_23 in inner_22 {
  283    283   
                let formatted_24 = ::aws_smithy_http::header::quote_header_value(inner_23.as_str());
  284    284   
                let header_value = formatted_24;
  285         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         285  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  286    286   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  287    287   
                        "header_string_set",
  288    288   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  289    289   
                    )
  290    290   
                })?;
  291    291   
                builder = builder.header("X-StringSet", header_value);
  292    292   
            }
  293    293   
        }
  294    294   
    }
  295    295   
    if let ::std::option::Option::Some(inner_25) = &input.header_integer_list {
  296    296   
        // Empty vec in header is serialized as an empty string
  297    297   
        if inner_25.is_empty() {
  298    298   
            builder = builder.header("X-IntegerList", "");
  299    299   
        } else {
  300    300   
            for inner_26 in inner_25 {
  301    301   
                let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_26);
  302    302   
                let formatted_27 = encoder.encode();
  303    303   
                let header_value = formatted_27;
  304         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         304  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  305    305   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  306    306   
                        "header_integer_list",
  307    307   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  308    308   
                    )
  309    309   
                })?;
  310    310   
                builder = builder.header("X-IntegerList", header_value);
  311    311   
            }
  312    312   
        }
  313    313   
    }
  314    314   
    if let ::std::option::Option::Some(inner_28) = &input.header_boolean_list {
  315    315   
        // Empty vec in header is serialized as an empty string
  316    316   
        if inner_28.is_empty() {
  317    317   
            builder = builder.header("X-BooleanList", "");
  318    318   
        } else {
  319    319   
            for inner_29 in inner_28 {
  320    320   
                let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_29);
  321    321   
                let formatted_30 = encoder.encode();
  322    322   
                let header_value = formatted_30;
  323         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         323  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  324    324   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  325    325   
                        "header_boolean_list",
  326    326   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  327    327   
                    )
  328    328   
                })?;
  329    329   
                builder = builder.header("X-BooleanList", header_value);
  330    330   
            }
  331    331   
        }
  332    332   
    }
  333    333   
    if let ::std::option::Option::Some(inner_31) = &input.header_timestamp_list {
  334    334   
        // Empty vec in header is serialized as an empty string
  335    335   
        if inner_31.is_empty() {
  336    336   
            builder = builder.header("X-TimestampList", "");
  337    337   
        } else {
  338    338   
            for inner_32 in inner_31 {
  339    339   
                let formatted_33 = inner_32.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  340    340   
                let header_value = formatted_33;
  341         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         341  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  342    342   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  343    343   
                        "header_timestamp_list",
  344    344   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  345    345   
                    )
  346    346   
                })?;
  347    347   
                builder = builder.header("X-TimestampList", header_value);
  348    348   
            }
  349    349   
        }
  350    350   
    }
  351    351   
    if let ::std::option::Option::Some(inner_34) = &input.header_enum {
  352    352   
        let formatted_35 = inner_34.as_str();
  353    353   
        let header_value = formatted_35;
  354         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         354  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  355    355   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  356    356   
                "header_enum",
  357    357   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  358    358   
            )
  359    359   
        })?;
  360    360   
        builder = builder.header("X-Enum", header_value);
  361    361   
    }
  362    362   
    if let ::std::option::Option::Some(inner_36) = &input.header_enum_list {
  363    363   
        // Empty vec in header is serialized as an empty string
  364    364   
        if inner_36.is_empty() {
  365    365   
            builder = builder.header("X-EnumList", "");
  366    366   
        } else {
  367    367   
            for inner_37 in inner_36 {
  368    368   
                let formatted_38 = ::aws_smithy_http::header::quote_header_value(inner_37.as_str());
  369    369   
                let header_value = formatted_38;
  370         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         370  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  371    371   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  372    372   
                        "header_enum_list",
  373    373   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  374    374   
                    )
  375    375   
                })?;
  376    376   
                builder = builder.header("X-EnumList", header_value);
  377    377   
            }
  378    378   
        }
  379    379   
    }
  380    380   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_null_and_empty_headers_client.rs

@@ -23,23 +96,96 @@
   43     43   
            crate::protocol_serde::shape_null_and_empty_headers_client_output::de_c_header(_response_headers).map_err(|_| {
   44     44   
                crate::operation::null_and_empty_headers_client::NullAndEmptyHeadersClientError::unhandled("Failed to parse c from header `X-C")
   45     45   
            })?,
   46     46   
        );
   47     47   
        output.build()
   48     48   
    })
   49     49   
}
   50     50   
   51     51   
pub fn ser_null_and_empty_headers_client_headers(
   52     52   
    input: &crate::operation::null_and_empty_headers_client::NullAndEmptyHeadersClientInput,
   53         -
    mut builder: ::http::request::Builder,
   54         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          53  +
    mut builder: ::http_1x::request::Builder,
          54  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   55     55   
    if let ::std::option::Option::Some(inner_1) = &input.a {
   56     56   
        let formatted_2 = inner_1.as_str();
   57     57   
        let header_value = formatted_2;
   58         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          58  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   59     59   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   60     60   
                "a",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("X-A", header_value);
   65     65   
    }
   66     66   
    if let ::std::option::Option::Some(inner_3) = &input.b {
   67     67   
        let formatted_4 = inner_3.as_str();
   68     68   
        let header_value = formatted_4;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "b",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("X-B", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_5) = &input.c {
   78     78   
        // Empty vec in header is serialized as an empty string
   79     79   
        if inner_5.is_empty() {
   80     80   
            builder = builder.header("X-C", "");
   81     81   
        } else {
   82     82   
            for inner_6 in inner_5 {
   83     83   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   84     84   
                let header_value = formatted_7;
   85         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          85  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   86     86   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   87     87   
                        "c",
   88     88   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
   89     89   
                    )
   90     90   
                })?;
   91     91   
                builder = builder.header("X-C", header_value);
   92     92   
            }
   93     93   
        }
   94     94   
    }
   95     95   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_null_and_empty_headers_server.rs

@@ -23,23 +96,96 @@
   43     43   
            crate::protocol_serde::shape_null_and_empty_headers_server_output::de_c_header(_response_headers).map_err(|_| {
   44     44   
                crate::operation::null_and_empty_headers_server::NullAndEmptyHeadersServerError::unhandled("Failed to parse c from header `X-C")
   45     45   
            })?,
   46     46   
        );
   47     47   
        output.build()
   48     48   
    })
   49     49   
}
   50     50   
   51     51   
pub fn ser_null_and_empty_headers_server_headers(
   52     52   
    input: &crate::operation::null_and_empty_headers_server::NullAndEmptyHeadersServerInput,
   53         -
    mut builder: ::http::request::Builder,
   54         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          53  +
    mut builder: ::http_1x::request::Builder,
          54  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   55     55   
    if let ::std::option::Option::Some(inner_1) = &input.a {
   56     56   
        let formatted_2 = inner_1.as_str();
   57     57   
        let header_value = formatted_2;
   58         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          58  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   59     59   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   60     60   
                "a",
   61     61   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   62     62   
            )
   63     63   
        })?;
   64     64   
        builder = builder.header("X-A", header_value);
   65     65   
    }
   66     66   
    if let ::std::option::Option::Some(inner_3) = &input.b {
   67     67   
        let formatted_4 = inner_3.as_str();
   68     68   
        let header_value = formatted_4;
   69         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          69  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   70     70   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     71   
                "b",
   72     72   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     73   
            )
   74     74   
        })?;
   75     75   
        builder = builder.header("X-B", header_value);
   76     76   
    }
   77     77   
    if let ::std::option::Option::Some(inner_5) = &input.c {
   78     78   
        // Empty vec in header is serialized as an empty string
   79     79   
        if inner_5.is_empty() {
   80     80   
            builder = builder.header("X-C", "");
   81     81   
        } else {
   82     82   
            for inner_6 in inner_5 {
   83     83   
                let formatted_7 = ::aws_smithy_http::header::quote_header_value(inner_6.as_str());
   84     84   
                let header_value = formatted_7;
   85         -
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          85  +
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   86     86   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
   87     87   
                        "c",
   88     88   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
   89     89   
                    )
   90     90   
                })?;
   91     91   
                builder = builder.header("X-C", header_value);
   92     92   
            }
   93     93   
        }
   94     94   
    }
   95     95   
    Ok(builder)

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_put_with_content_encoding.rs

@@ -6,6 +63,63 @@
   26     26   
> {
   27     27   
    Ok({
   28     28   
        #[allow(unused_mut)]
   29     29   
        let mut output = crate::operation::put_with_content_encoding::builders::PutWithContentEncodingOutputBuilder::default();
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_put_with_content_encoding_headers(
   35     35   
    input: &crate::operation::put_with_content_encoding::PutWithContentEncodingInput,
   36         -
    mut builder: ::http::request::Builder,
   37         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    mut builder: ::http_1x::request::Builder,
          37  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.encoding {
   39     39   
        let formatted_2 = inner_1.as_str();
   40     40   
        let header_value = formatted_2;
   41         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          41  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   42     42   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     43   
                "encoding",
   44     44   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     45   
            )
   46     46   
        })?;
   47     47   
        builder = builder.header("Content-Encoding", header_value);
   48     48   
    }
   49     49   
    Ok(builder)
   50     50   
}
   51     51

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_simple_scalar_properties.rs

@@ -13,13 +78,78 @@
   33     33   
            crate::protocol_serde::shape_simple_scalar_properties_output::de_foo_header(_response_headers).map_err(|_| {
   34     34   
                crate::operation::simple_scalar_properties::SimpleScalarPropertiesError::unhandled("Failed to parse foo from header `X-Foo")
   35     35   
            })?,
   36     36   
        );
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_simple_scalar_properties_headers(
   42     42   
    input: &crate::operation::simple_scalar_properties::SimpleScalarPropertiesInput,
   43         -
    mut builder: ::http::request::Builder,
   44         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          43  +
    mut builder: ::http_1x::request::Builder,
          44  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.foo {
   46     46   
        let formatted_2 = inner_1.as_str();
   47     47   
        let header_value = formatted_2;
   48         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          48  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   49     49   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     50   
                "foo",
   51     51   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     52   
            )
   53     53   
        })?;
   54     54   
        builder = builder.header("X-Foo", header_value);
   55     55   
    }
   56     56   
    Ok(builder)
   57     57   
}
   58     58

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/protocol_serde/shape_timestamp_format_headers.rs

@@ -55,55 +165,165 @@
   75     75   
                    "Failed to parse targetHttpDate from header `X-targetHttpDate",
   76     76   
                )
   77     77   
            })?,
   78     78   
        );
   79     79   
        output.build()
   80     80   
    })
   81     81   
}
   82     82   
   83     83   
pub fn ser_timestamp_format_headers_headers(
   84     84   
    input: &crate::operation::timestamp_format_headers::TimestampFormatHeadersInput,
   85         -
    mut builder: ::http::request::Builder,
   86         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          85  +
    mut builder: ::http_1x::request::Builder,
          86  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   87     87   
    if let ::std::option::Option::Some(inner_1) = &input.member_epoch_seconds {
   88     88   
        let formatted_2 = inner_1.fmt(::aws_smithy_types::date_time::Format::EpochSeconds)?;
   89     89   
        let header_value = formatted_2;
   90         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
          90  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
   91     91   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
   92     92   
                "member_epoch_seconds",
   93     93   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
   94     94   
            )
   95     95   
        })?;
   96     96   
        builder = builder.header("X-memberEpochSeconds", header_value);
   97     97   
    }
   98     98   
    if let ::std::option::Option::Some(inner_3) = &input.member_http_date {
   99     99   
        let formatted_4 = inner_3.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  100    100   
        let header_value = formatted_4;
  101         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         101  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  102    102   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  103    103   
                "member_http_date",
  104    104   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  105    105   
            )
  106    106   
        })?;
  107    107   
        builder = builder.header("X-memberHttpDate", header_value);
  108    108   
    }
  109    109   
    if let ::std::option::Option::Some(inner_5) = &input.member_date_time {
  110    110   
        let formatted_6 = inner_5.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  111    111   
        let header_value = formatted_6;
  112         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         112  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  113    113   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  114    114   
                "member_date_time",
  115    115   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  116    116   
            )
  117    117   
        })?;
  118    118   
        builder = builder.header("X-memberDateTime", header_value);
  119    119   
    }
  120    120   
    if let ::std::option::Option::Some(inner_7) = &input.default_format {
  121    121   
        let formatted_8 = inner_7.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  122    122   
        let header_value = formatted_8;
  123         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         123  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  124    124   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  125    125   
                "default_format",
  126    126   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  127    127   
            )
  128    128   
        })?;
  129    129   
        builder = builder.header("X-defaultFormat", header_value);
  130    130   
    }
  131    131   
    if let ::std::option::Option::Some(inner_9) = &input.target_epoch_seconds {
  132    132   
        let formatted_10 = inner_9.fmt(::aws_smithy_types::date_time::Format::EpochSeconds)?;
  133    133   
        let header_value = formatted_10;
  134         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         134  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  135    135   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  136    136   
                "target_epoch_seconds",
  137    137   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  138    138   
            )
  139    139   
        })?;
  140    140   
        builder = builder.header("X-targetEpochSeconds", header_value);
  141    141   
    }
  142    142   
    if let ::std::option::Option::Some(inner_11) = &input.target_http_date {
  143    143   
        let formatted_12 = inner_11.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
  144    144   
        let header_value = formatted_12;
  145         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         145  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  146    146   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  147    147   
                "target_http_date",
  148    148   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  149    149   
            )
  150    150   
        })?;
  151    151   
        builder = builder.header("X-targetHttpDate", header_value);
  152    152   
    }
  153    153   
    if let ::std::option::Option::Some(inner_13) = &input.target_date_time {
  154    154   
        let formatted_14 = inner_13.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  155    155   
        let header_value = formatted_14;
  156         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         156  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  157    157   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  158    158   
                "target_date_time",
  159    159   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  160    160   
            )
  161    161   
        })?;
  162    162   
        builder = builder.header("X-targetDateTime", header_value);
  163    163   
    }
  164    164   
    Ok(builder)
  165    165   
}

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/serialization_settings.rs

@@ -1,1 +78,83 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
#![allow(dead_code)]
    8      8   
    9      9   
use aws_smithy_http::header::set_request_header_if_absent;
   10     10   
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
          11  +
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12     12   
   13     13   
/// Configuration for how default protocol headers are serialized
   14     14   
#[derive(Clone, Debug, Default)]
   15     15   
pub(crate) struct HeaderSerializationSettings {
   16     16   
    omit_default_content_length: bool,
   17     17   
    omit_default_content_type: bool,
   18     18   
}
   19     19   
   20     20   
impl HeaderSerializationSettings {
   21     21   
    /// Creates new [`HeaderSerializationSettings`]
   22     22   
    pub(crate) fn new() -> Self {
   23     23   
        Default::default()
   24     24   
    }
   25     25   
   26     26   
    /// Omit the default `Content-Length` header during serialization
   27     27   
    pub(crate) fn omit_default_content_length(self) -> Self {
   28     28   
        Self {
   29     29   
            omit_default_content_length: true,
   30     30   
            ..self
   31     31   
        }
   32     32   
    }
   33     33   
   34     34   
    /// Omit the default `Content-Type` header during serialization
   35     35   
    pub(crate) fn omit_default_content_type(self) -> Self {
   36     36   
        Self {
   37     37   
            omit_default_content_type: true,
   38     38   
            ..self
   39     39   
        }
   40     40   
    }
   41     41   
   42     42   
    /// Returns true if the given default header name should be serialized
   43     43   
    fn include_header(&self, header: &HeaderName) -> bool {
   44     44   
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45     45   
    }
   46     46   
   47     47   
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
          48  +
    pub(crate) fn set_default_header(
          49  +
        &self,
          50  +
        mut request: http_1x::request::Builder,
          51  +
        header_name: HeaderName,
          52  +
        value: &str,
          53  +
    ) -> http_1x::request::Builder {
   49     54   
        if self.include_header(&header_name) {
   50     55   
            request = set_request_header_if_absent(request, header_name, value);
   51     56   
        }
   52     57   
        request
   53     58   
    }
   54     59   
}
   55     60   
   56     61   
impl Storable for HeaderSerializationSettings {
   57     62   
    type Storer = StoreReplace<Self>;
   58     63   
}

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/Cargo.toml

@@ -1,1 +58,62 @@
   11     11   
protocol = "aws.protocols#restXml"
   12     12   
[dependencies.aws-smithy-async]
   13     13   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-async"
   14     14   
[dependencies.aws-smithy-http]
   15     15   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
   16     16   
[dependencies.aws-smithy-runtime]
   17     17   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime"
   18     18   
features = ["client"]
   19     19   
[dependencies.aws-smithy-runtime-api]
   20     20   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
   21         -
features = ["client", "http-02x"]
          21  +
features = ["client", "http-1x"]
   22     22   
[dependencies.aws-smithy-types]
   23     23   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
          24  +
features = ["http-body-1-x"]
   24     25   
[dependencies.aws-smithy-xml]
   25     26   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-xml"
   26     27   
[dependencies.fastrand]
   27     28   
version = "2.0.0"
   28     29   
[dependencies.http]
   29     30   
version = "0.2.9"
          31  +
[dependencies.http-1x]
          32  +
version = "1"
          33  +
package = "http"
   30     34   
[dependencies.md-5]
   31     35   
version = "0.10.0"
   32     36   
[dependencies.tracing]
   33     37   
version = "0.1"
   34     38   
[dev-dependencies.aws-smithy-http-client]
   35     39   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-client"
   36     40   
features = ["test-util"]
   37     41   
[dev-dependencies.aws-smithy-protocol-test]
   38     42   
path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
   39     43   
[dev-dependencies.bytes]

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/attribute_party.rs

@@ -151,151 +217,217 @@
  171    171   
                _input: &crate::operation::attribute_party::AttributePartyInput,
  172    172   
                output: &mut ::std::string::String,
  173    173   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  174    174   
                use ::std::fmt::Write as _;
  175    175   
                ::std::write!(output, "/AttributeParty").expect("formatting should succeed");
  176    176   
                ::std::result::Result::Ok(())
  177    177   
            }
  178    178   
            #[allow(clippy::unnecessary_wraps)]
  179    179   
            fn update_http_builder(
  180    180   
                input: &crate::operation::attribute_party::AttributePartyInput,
  181         -
                builder: ::http::request::Builder,
  182         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         181  +
                builder: ::http_1x::request::Builder,
         182  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  183    183   
                let mut uri = ::std::string::String::new();
  184    184   
                uri_base(input, &mut uri)?;
  185    185   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  186    186   
            }
  187         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         187  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  188    188   
            builder
  189    189   
        };
  190    190   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  191    191   
  192    192   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  193    193   
    }
  194    194   
}
  195    195   
#[derive(Debug)]
  196    196   
struct AttributePartyEndpointParamsInterceptor;
  197    197

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/checksum_required.rs

@@ -157,157 +230,230 @@
  177    177   
                _input: &crate::operation::checksum_required::ChecksumRequiredInput,
  178    178   
                output: &mut ::std::string::String,
  179    179   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  180    180   
                use ::std::fmt::Write as _;
  181    181   
                ::std::write!(output, "/ChecksumRequired").expect("formatting should succeed");
  182    182   
                ::std::result::Result::Ok(())
  183    183   
            }
  184    184   
            #[allow(clippy::unnecessary_wraps)]
  185    185   
            fn update_http_builder(
  186    186   
                input: &crate::operation::checksum_required::ChecksumRequiredInput,
  187         -
                builder: ::http::request::Builder,
  188         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         187  +
                builder: ::http_1x::request::Builder,
         188  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  189    189   
                let mut uri = ::std::string::String::new();
  190    190   
                uri_base(input, &mut uri)?;
  191    191   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  192    192   
            }
  193         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  194         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         193  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         194  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  195    195   
            builder
  196    196   
        };
  197    197   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_checksum_required::ser_checksum_required_op_input(&input)?);
  198    198   
        if let Some(content_length) = body.content_length() {
  199    199   
            let content_length = content_length.to_string();
  200         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         200  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  201    201   
        }
  202    202   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  203    203   
    }
  204    204   
}
  205    205   
#[derive(Debug)]
  206    206   
struct ChecksumRequiredEndpointParamsInterceptor;
  207    207   
  208    208   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChecksumRequiredEndpointParamsInterceptor {
  209    209   
    fn name(&self) -> &'static str {
  210    210   
        "ChecksumRequiredEndpointParamsInterceptor"

tmp-codegen-diff/codegen-client-test/rest_xml_extras/rust-client-codegen/src/operation/create_foo.rs

@@ -149,149 +222,222 @@
  169    169   
                _input: &crate::operation::create_foo::CreateFooInput,
  170    170   
                output: &mut ::std::string::String,
  171    171   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  172    172   
                use ::std::fmt::Write as _;
  173    173   
                ::std::write!(output, "/reused-input").expect("formatting should succeed");
  174    174   
                ::std::result::Result::Ok(())
  175    175   
            }
  176    176   
            #[allow(clippy::unnecessary_wraps)]
  177    177   
            fn update_http_builder(
  178    178   
                input: &crate::operation::create_foo::CreateFooInput,
  179         -
                builder: ::http::request::Builder,
  180         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         179  +
                builder: ::http_1x::request::Builder,
         180  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  181    181   
                let mut uri = ::std::string::String::new();
  182    182   
                uri_base(input, &mut uri)?;
  183    183   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  184    184   
            }
  185         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  186         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         185  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         186  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  187    187   
            builder
  188    188   
        };
  189    189   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_foo::ser_create_foo_op_input(&input)?);
  190    190   
        if let Some(content_length) = body.content_length() {
  191    191   
            let content_length = content_length.to_string();
  192         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         192  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  193    193   
        }
  194    194   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  195    195   
    }
  196    196   
}
  197    197   
#[derive(Debug)]
  198    198   
struct CreateFooEndpointParamsInterceptor;
  199    199   
  200    200   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateFooEndpointParamsInterceptor {
  201    201   
    fn name(&self) -> &'static str {
  202    202   
        "CreateFooEndpointParamsInterceptor"