Server Test

Server Test

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5

Files changed:

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_top_level.rs

@@ -1,1 +67,107 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:516 */
    2      3   
pub(crate) fn de_top_level<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::model::top_level::Builder>,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
>
    8      9   
where
    9     10   
    I: Iterator<
   10     11   
        Item = Result<
   11     12   
            ::aws_smithy_json::deserialize::Token<'a>,
   12     13   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   13     14   
        >,
   14     15   
    >,
   15     16   
{
          17  +
    /* JsonParserGenerator.kt:712 */
   16     18   
    match tokens.next().transpose()? {
          19  +
        /* JsonParserGenerator.kt:713 */
   17     20   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
   18     21   
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
          22  +
            /* RustType.kt:534 */
   19     23   
            #[allow(unused_mut)]
          24  +
            /* JsonParserGenerator.kt:526 */
   20     25   
            let mut builder = crate::model::top_level::Builder::default();
          26  +
            /* JsonParserGenerator.kt:684 */
   21     27   
            loop {
          28  +
                /* JsonParserGenerator.kt:685 */
   22     29   
                match tokens.next().transpose()? {
          30  +
                    /* JsonParserGenerator.kt:686 */
   23     31   
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
   24         -
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key
   25         -
                        .to_unescaped()?
   26         -
                        .as_ref()
   27         -
                    {
   28         -
                        "dialog" => {
   29         -
                            if let Some(v) = crate::protocol_serde::shape_dialog::de_dialog(tokens)?
   30         -
                            {
   31         -
                                builder = builder.set_dialog(v);
          32  +
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
          33  +
                        /* JsonParserGenerator.kt:260 */
          34  +
                        match key.to_unescaped()?.as_ref() {
          35  +
                            /* JsonParserGenerator.kt:262 */
          36  +
                            "dialog" => {
          37  +
                                /* JsonParserGenerator.kt:276 */
          38  +
                                if let Some(v) =
          39  +
                                    /* JsonParserGenerator.kt:544 */
          40  +
                                    crate::protocol_serde::shape_dialog::de_dialog(tokens)?
          41  +
                                /* JsonParserGenerator.kt:278 */
          42  +
                                {
          43  +
                                    builder = builder.set_dialog(v);
          44  +
                                }
          45  +
                                /* JsonParserGenerator.kt:262 */
   32     46   
                            }
   33         -
                        }
   34         -
                        "dialogList" => {
   35         -
                            if let Some(v) =
   36         -
                                crate::protocol_serde::shape_dialog_list::de_dialog_list(tokens)?
   37         -
                            {
   38         -
                                builder = builder.set_dialog_list(v);
          47  +
                            /* JsonParserGenerator.kt:262 */
          48  +
                            "dialogList" => {
          49  +
                                /* JsonParserGenerator.kt:276 */
          50  +
                                if let Some(v) =
          51  +
                                    /* JsonParserGenerator.kt:451 */
          52  +
                                    crate::protocol_serde::shape_dialog_list::de_dialog_list(
          53  +
                                            tokens,
          54  +
                                        )?
          55  +
                                /* JsonParserGenerator.kt:278 */
          56  +
                                {
          57  +
                                    builder = builder.set_dialog_list(v);
          58  +
                                }
          59  +
                                /* JsonParserGenerator.kt:262 */
   39     60   
                            }
   40         -
                        }
   41         -
                        "dialogMap" => {
   42         -
                            if let Some(v) =
   43         -
                                crate::protocol_serde::shape_dialog_map::de_dialog_map(tokens)?
   44         -
                            {
   45         -
                                builder = builder.set_dialog_map(v);
          61  +
                            /* JsonParserGenerator.kt:262 */
          62  +
                            "dialogMap" => {
          63  +
                                /* JsonParserGenerator.kt:276 */
          64  +
                                if let Some(v) =
          65  +
                                    /* JsonParserGenerator.kt:509 */
          66  +
                                    crate::protocol_serde::shape_dialog_map::de_dialog_map(
          67  +
                                            tokens,
          68  +
                                        )?
          69  +
                                /* JsonParserGenerator.kt:278 */
          70  +
                                {
          71  +
                                    builder = builder.set_dialog_map(v);
          72  +
                                }
          73  +
                                /* JsonParserGenerator.kt:262 */
   46     74   
                            }
          75  +
                            /* JsonParserGenerator.kt:290 */
          76  +
                            _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:260 */
   47     77   
                        }
   48         -
                        _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
   49         -
                    },
          78  +
                        /* JsonParserGenerator.kt:686 */
          79  +
                    }
          80  +
                    /* JsonParserGenerator.kt:695 */
   50     81   
                    other => {
   51     82   
                        return Err(
   52     83   
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   53     84   
                                format!("expected object key or end object, found: {other:?}"),
   54     85   
                            ),
   55     86   
                        )
   56         -
                    }
          87  +
                    } /* JsonParserGenerator.kt:685 */
   57     88   
                }
          89  +
                /* JsonParserGenerator.kt:684 */
   58     90   
            }
          91  +
            /* JsonParserGenerator.kt:540 */
   59     92   
            Ok(Some(builder))
          93  +
            /* JsonParserGenerator.kt:713 */
   60     94   
        }
   61         -
        _ => Err(
   62         -
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   63         -
                "expected start object or null",
   64         -
            ),
   65         -
        ),
          95  +
        /* JsonParserGenerator.kt:722 */
          96  +
        _ => {
          97  +
            /* JsonParserGenerator.kt:723 */
          98  +
            Err(
          99  +
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         100  +
                    "expected start object or null",
         101  +
                ),
         102  +
            )
         103  +
            /* JsonParserGenerator.kt:722 */
         104  +
        } /* JsonParserGenerator.kt:712 */
   66    105   
    }
         106  +
    /* JsonParserGenerator.kt:516 */
   67    107   
}

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_union_payload.rs

@@ -1,1 +127,166 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:175 */
    2      3   
pub(crate) fn de_union_payload_payload(
    3      4   
    input: &[u8],
    4      5   
) -> ::std::result::Result<
    5      6   
    crate::model::UnionPayload,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
> {
           9  +
    /* JsonParserGenerator.kt:187 */
    8     10   
    let mut tokens_owned =
    9     11   
        ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(input))
   10     12   
            .peekable();
   11     13   
    let tokens = &mut tokens_owned;
          14  +
    /* JsonParserGenerator.kt:194 */
   12     15   
    let result =
   13         -
        crate::protocol_serde::shape_union_payload::de_union_payload(tokens)?.ok_or_else(|| {
   14         -
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   15         -
                "expected payload member value",
   16         -
            )
   17         -
        });
          16  +
    /* JsonParserGenerator.kt:660 */crate::protocol_serde::shape_union_payload::de_union_payload(tokens)?
          17  +
    /* JsonParserGenerator.kt:196 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("expected payload member value"));
          18  +
    /* JsonParserGenerator.kt:250 */
   18     19   
    if tokens.next().is_some() {
          20  +
        /* JsonParserGenerator.kt:251 */
   19     21   
        return Err(
   20     22   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   21     23   
                "found more JSON tokens after completing parsing",
   22     24   
            ),
   23     25   
        );
          26  +
        /* JsonParserGenerator.kt:250 */
   24     27   
    }
          28  +
    /* JsonParserGenerator.kt:198 */
   25     29   
    result
          30  +
    /* JsonParserGenerator.kt:175 */
   26     31   
}
   27     32   
          33  +
/* JsonSerializerGenerator.kt:547 */
   28     34   
pub fn ser_union_payload(
   29     35   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
   30     36   
    input: &crate::model::UnionPayload,
   31     37   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
          38  +
    /* JsonSerializerGenerator.kt:556 */
   32     39   
    match input {
          40  +
        /* JsonSerializerGenerator.kt:564 */
   33     41   
        crate::model::UnionPayload::Greeting(inner) => {
   34         -
            object.key("greeting").string(inner.as_str());
          42  +
            /* SerializerUtil.kt:42 */
          43  +
            {
          44  +
                /* JsonSerializerGenerator.kt:423 */
          45  +
                object.key("greeting").string(inner.as_str());
          46  +
                /* SerializerUtil.kt:42 */
          47  +
            }
          48  +
            /* JsonSerializerGenerator.kt:564 */
   35     49   
        }
          50  +
        /* JsonSerializerGenerator.kt:556 */
   36     51   
    }
          52  +
    /* JsonSerializerGenerator.kt:576 */
   37     53   
    Ok(())
          54  +
    /* JsonSerializerGenerator.kt:547 */
   38     55   
}
   39     56   
          57  +
/* JsonParserGenerator.kt:551 */
   40     58   
pub(crate) fn de_union_payload<'a, I>(
   41     59   
    tokens: &mut ::std::iter::Peekable<I>,
   42     60   
) -> ::std::result::Result<
   43     61   
    Option<crate::model::UnionPayload>,
   44     62   
    ::aws_smithy_json::deserialize::error::DeserializeError,
   45     63   
>
   46     64   
where
   47     65   
    I: Iterator<
   48     66   
        Item = Result<
   49     67   
            ::aws_smithy_json::deserialize::Token<'a>,
   50     68   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   51     69   
        >,
   52     70   
    >,
   53     71   
{
          72  +
    /* JsonParserGenerator.kt:565 */
   54     73   
    let mut variant = None;
          74  +
    /* JsonParserGenerator.kt:567 */
   55     75   
    match tokens.next().transpose()? {
          76  +
        /* JsonParserGenerator.kt:568 */
   56     77   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
   57         -
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
   58         -
            match tokens.next().transpose()? {
   59         -
                Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
   60         -
                Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
   61         -
                    if let ::std::option::Option::Some(::std::result::Result::Ok(
   62         -
                        ::aws_smithy_json::deserialize::Token::ValueNull { .. },
   63         -
                    )) = tokens.peek()
   64         -
                    {
   65         -
                        let _ = tokens.next().expect("peek returned a token")?;
   66         -
                        continue;
   67         -
                    }
   68         -
                    let key = key.to_unescaped()?;
   69         -
                    if key == "__type" {
   70         -
                        ::aws_smithy_json::deserialize::token::skip_value(tokens)?;
   71         -
                        continue;
   72         -
                    }
   73         -
                    if variant.is_some() {
   74         -
                        return Err(
   75         -
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   76         -
                                "encountered mixed variants in union",
   77         -
                            ),
   78         -
                        );
   79         -
                    }
   80         -
                    variant = match key.as_ref() {
   81         -
                        "greeting" => Some(crate::model::UnionPayload::Greeting(
   82         -
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
   83         -
                                tokens.next(),
   84         -
                            )?
   85         -
                            .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   86         -
                            .transpose()?
   87         -
                            .ok_or_else(|| {
   88         -
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   89         -
                                    "value for 'greeting' cannot be null",
   90         -
                                )
   91         -
                            })?,
   92         -
                        )),
   93         -
                        variant => {
          78  +
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
          79  +
            /* JsonParserGenerator.kt:684 */
          80  +
            loop {
          81  +
                /* JsonParserGenerator.kt:685 */
          82  +
                match tokens.next().transpose()? {
          83  +
                    /* JsonParserGenerator.kt:686 */
          84  +
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
          85  +
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
          86  +
                        /* JsonParserGenerator.kt:576 */
          87  +
                        if let ::std::option::Option::Some(::std::result::Result::Ok(
          88  +
                            ::aws_smithy_json::deserialize::Token::ValueNull { .. },
          89  +
                        )) = tokens.peek()
          90  +
                        {
          91  +
                            let _ = tokens.next().expect("peek returned a token")?;
          92  +
                            continue;
          93  +
                        }
          94  +
                        /* JsonParserGenerator.kt:585 */
          95  +
                        let key = key.to_unescaped()?;
          96  +
                        if key == "__type" {
          97  +
                            ::aws_smithy_json::deserialize::token::skip_value(tokens)?;
          98  +
                            continue;
          99  +
                        }
         100  +
                        if variant.is_some() {
   94    101   
                            return Err(
   95    102   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   96         -
                                    format!("unexpected union variant: {variant}"),
         103  +
                                    "encountered mixed variants in union",
   97    104   
                                ),
   98         -
                            )
         105  +
                            );
   99    106   
                        }
  100         -
                    };
  101         -
                }
  102         -
                other => {
  103         -
                    return Err(
  104         -
                        ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
  105         -
                            "expected object key or end object, found: {other:?}"
  106         -
                        )),
  107         -
                    )
         107  +
                        /* JsonParserGenerator.kt:598 */
         108  +
                        variant = match key.as_ref() {
         109  +
                            /* JsonParserGenerator.kt:601 */
         110  +
                            "greeting" => {
         111  +
                                /* JsonParserGenerator.kt:611 */
         112  +
                                Some(crate::model::UnionPayload::Greeting(
         113  +
                                    /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
         114  +
                                        /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
         115  +
                                            /* JsonParserGenerator.kt:348 */u.into_owned()
         116  +
                                        /* JsonParserGenerator.kt:339 */)
         117  +
                                    /* JsonParserGenerator.kt:354 */).transpose()?
         118  +
                                    /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'greeting' cannot be null"))?
         119  +
                                /* JsonParserGenerator.kt:611 */))
         120  +
                                /* JsonParserGenerator.kt:601 */
         121  +
                            }
         122  +
                            /* JsonParserGenerator.kt:634 */
         123  +
                            variant => {
         124  +
                                return Err(
         125  +
                                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         126  +
                                        format!("unexpected union variant: {variant}"),
         127  +
                                    ),
         128  +
                                )
         129  +
                            } /* JsonParserGenerator.kt:598 */
         130  +
                        };
         131  +
                        /* JsonParserGenerator.kt:686 */
         132  +
                    }
         133  +
                    /* JsonParserGenerator.kt:695 */
         134  +
                    other => {
         135  +
                        return Err(
         136  +
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         137  +
                                format!("expected object key or end object, found: {other:?}"),
         138  +
                            ),
         139  +
                        )
         140  +
                    } /* JsonParserGenerator.kt:685 */
  108    141   
                }
         142  +
                /* JsonParserGenerator.kt:684 */
  109    143   
            }
  110         -
        },
         144  +
            /* JsonParserGenerator.kt:568 */
         145  +
        }
         146  +
        /* JsonParserGenerator.kt:642 */
  111    147   
        _ => {
  112    148   
            return Err(
  113    149   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  114    150   
                    "expected start object or null",
  115    151   
                ),
  116    152   
            )
  117         -
        }
         153  +
        } /* JsonParserGenerator.kt:567 */
  118    154   
    }
         155  +
    /* JsonParserGenerator.kt:649 */
  119    156   
    if variant.is_none() {
  120    157   
        return Err(
  121    158   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  122    159   
                "Union did not contain a valid variant.",
  123    160   
            ),
  124    161   
        );
  125    162   
    }
         163  +
    /* JsonParserGenerator.kt:657 */
  126    164   
    Ok(variant)
         165  +
    /* JsonParserGenerator.kt:551 */
  127    166   
}

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_union_with_json_name.rs

@@ -1,1 +131,181 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:551 */
    2      3   
pub(crate) fn de_union_with_json_name<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::model::UnionWithJsonName>,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
>
    8      9   
where
    9     10   
    I: Iterator<
   10     11   
        Item = Result<
   11     12   
            ::aws_smithy_json::deserialize::Token<'a>,
   12     13   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   13     14   
        >,
   14     15   
    >,
   15     16   
{
          17  +
    /* JsonParserGenerator.kt:565 */
   16     18   
    let mut variant = None;
          19  +
    /* JsonParserGenerator.kt:567 */
   17     20   
    match tokens.next().transpose()? {
          21  +
        /* JsonParserGenerator.kt:568 */
   18     22   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => return Ok(None),
   19         -
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => loop {
   20         -
            match tokens.next().transpose()? {
   21         -
                Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
   22         -
                Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
   23         -
                    if let ::std::option::Option::Some(::std::result::Result::Ok(
   24         -
                        ::aws_smithy_json::deserialize::Token::ValueNull { .. },
   25         -
                    )) = tokens.peek()
   26         -
                    {
   27         -
                        let _ = tokens.next().expect("peek returned a token")?;
   28         -
                        continue;
   29         -
                    }
   30         -
                    let key = key.to_unescaped()?;
   31         -
                    if key == "__type" {
   32         -
                        ::aws_smithy_json::deserialize::token::skip_value(tokens)?;
   33         -
                        continue;
   34         -
                    }
   35         -
                    if variant.is_some() {
   36         -
                        return Err(
   37         -
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   38         -
                                "encountered mixed variants in union",
   39         -
                            ),
   40         -
                        );
   41         -
                    }
   42         -
                    variant = match key.as_ref() {
   43         -
                        "FOO" => Some(crate::model::UnionWithJsonName::Foo(
   44         -
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
   45         -
                                tokens.next(),
   46         -
                            )?
   47         -
                            .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   48         -
                            .transpose()?
   49         -
                            .ok_or_else(|| {
   50         -
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   51         -
                                    "value for 'foo' cannot be null",
   52         -
                                )
   53         -
                            })?,
   54         -
                        )),
   55         -
                        "bar" => Some(crate::model::UnionWithJsonName::Bar(
   56         -
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
   57         -
                                tokens.next(),
   58         -
                            )?
   59         -
                            .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   60         -
                            .transpose()?
   61         -
                            .ok_or_else(|| {
   62         -
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   63         -
                                    "value for 'bar' cannot be null",
   64         -
                                )
   65         -
                            })?,
   66         -
                        )),
   67         -
                        "_baz" => Some(crate::model::UnionWithJsonName::Baz(
   68         -
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
   69         -
                                tokens.next(),
   70         -
                            )?
   71         -
                            .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   72         -
                            .transpose()?
   73         -
                            .ok_or_else(|| {
   74         -
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   75         -
                                    "value for 'baz' cannot be null",
   76         -
                                )
   77         -
                            })?,
   78         -
                        )),
   79         -
                        variant => {
          23  +
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
          24  +
            /* JsonParserGenerator.kt:684 */
          25  +
            loop {
          26  +
                /* JsonParserGenerator.kt:685 */
          27  +
                match tokens.next().transpose()? {
          28  +
                    /* JsonParserGenerator.kt:686 */
          29  +
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
          30  +
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
          31  +
                        /* JsonParserGenerator.kt:576 */
          32  +
                        if let ::std::option::Option::Some(::std::result::Result::Ok(
          33  +
                            ::aws_smithy_json::deserialize::Token::ValueNull { .. },
          34  +
                        )) = tokens.peek()
          35  +
                        {
          36  +
                            let _ = tokens.next().expect("peek returned a token")?;
          37  +
                            continue;
          38  +
                        }
          39  +
                        /* JsonParserGenerator.kt:585 */
          40  +
                        let key = key.to_unescaped()?;
          41  +
                        if key == "__type" {
          42  +
                            ::aws_smithy_json::deserialize::token::skip_value(tokens)?;
          43  +
                            continue;
          44  +
                        }
          45  +
                        if variant.is_some() {
   80     46   
                            return Err(
   81     47   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   82         -
                                    format!("unexpected union variant: {variant}"),
          48  +
                                    "encountered mixed variants in union",
   83     49   
                                ),
   84         -
                            )
          50  +
                            );
   85     51   
                        }
   86         -
                    };
   87         -
                }
   88         -
                other => {
   89         -
                    return Err(
   90         -
                        ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
   91         -
                            "expected object key or end object, found: {other:?}"
   92         -
                        )),
   93         -
                    )
          52  +
                        /* JsonParserGenerator.kt:598 */
          53  +
                        variant = match key.as_ref() {
          54  +
                            /* JsonParserGenerator.kt:601 */
          55  +
                            "FOO" => {
          56  +
                                /* JsonParserGenerator.kt:611 */
          57  +
                                Some(crate::model::UnionWithJsonName::Foo(
          58  +
                                    /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          59  +
                                        /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          60  +
                                            /* JsonParserGenerator.kt:348 */u.into_owned()
          61  +
                                        /* JsonParserGenerator.kt:339 */)
          62  +
                                    /* JsonParserGenerator.kt:354 */).transpose()?
          63  +
                                    /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'foo' cannot be null"))?
          64  +
                                /* JsonParserGenerator.kt:611 */))
          65  +
                                /* JsonParserGenerator.kt:601 */
          66  +
                            }
          67  +
                            /* JsonParserGenerator.kt:601 */
          68  +
                            "bar" => {
          69  +
                                /* JsonParserGenerator.kt:611 */
          70  +
                                Some(crate::model::UnionWithJsonName::Bar(
          71  +
                                    /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          72  +
                                        /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          73  +
                                            /* JsonParserGenerator.kt:348 */u.into_owned()
          74  +
                                        /* JsonParserGenerator.kt:339 */)
          75  +
                                    /* JsonParserGenerator.kt:354 */).transpose()?
          76  +
                                    /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'bar' cannot be null"))?
          77  +
                                /* JsonParserGenerator.kt:611 */))
          78  +
                                /* JsonParserGenerator.kt:601 */
          79  +
                            }
          80  +
                            /* JsonParserGenerator.kt:601 */
          81  +
                            "_baz" => {
          82  +
                                /* JsonParserGenerator.kt:611 */
          83  +
                                Some(crate::model::UnionWithJsonName::Baz(
          84  +
                                    /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          85  +
                                        /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          86  +
                                            /* JsonParserGenerator.kt:348 */u.into_owned()
          87  +
                                        /* JsonParserGenerator.kt:339 */)
          88  +
                                    /* JsonParserGenerator.kt:354 */).transpose()?
          89  +
                                    /* JsonParserGenerator.kt:670 */.ok_or_else(|| ::aws_smithy_json::deserialize::error::DeserializeError::custom("value for 'baz' cannot be null"))?
          90  +
                                /* JsonParserGenerator.kt:611 */))
          91  +
                                /* JsonParserGenerator.kt:601 */
          92  +
                            }
          93  +
                            /* JsonParserGenerator.kt:634 */
          94  +
                            variant => {
          95  +
                                return Err(
          96  +
                                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          97  +
                                        format!("unexpected union variant: {variant}"),
          98  +
                                    ),
          99  +
                                )
         100  +
                            } /* JsonParserGenerator.kt:598 */
         101  +
                        };
         102  +
                        /* JsonParserGenerator.kt:686 */
         103  +
                    }
         104  +
                    /* JsonParserGenerator.kt:695 */
         105  +
                    other => {
         106  +
                        return Err(
         107  +
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         108  +
                                format!("expected object key or end object, found: {other:?}"),
         109  +
                            ),
         110  +
                        )
         111  +
                    } /* JsonParserGenerator.kt:685 */
   94    112   
                }
         113  +
                /* JsonParserGenerator.kt:684 */
   95    114   
            }
   96         -
        },
         115  +
            /* JsonParserGenerator.kt:568 */
         116  +
        }
         117  +
        /* JsonParserGenerator.kt:642 */
   97    118   
        _ => {
   98    119   
            return Err(
   99    120   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  100    121   
                    "expected start object or null",
  101    122   
                ),
  102    123   
            )
  103         -
        }
         124  +
        } /* JsonParserGenerator.kt:567 */
  104    125   
    }
         126  +
    /* JsonParserGenerator.kt:649 */
  105    127   
    if variant.is_none() {
  106    128   
        return Err(
  107    129   
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
  108    130   
                "Union did not contain a valid variant.",
  109    131   
            ),
  110    132   
        );
  111    133   
    }
         134  +
    /* JsonParserGenerator.kt:657 */
  112    135   
    Ok(variant)
         136  +
    /* JsonParserGenerator.kt:551 */
  113    137   
}
  114    138   
         139  +
/* JsonSerializerGenerator.kt:547 */
  115    140   
pub fn ser_union_with_json_name(
  116    141   
    object_1: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
  117    142   
    input: &crate::model::UnionWithJsonName,
  118    143   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
         144  +
    /* JsonSerializerGenerator.kt:556 */
  119    145   
    match input {
         146  +
        /* JsonSerializerGenerator.kt:564 */
  120    147   
        crate::model::UnionWithJsonName::Foo(inner) => {
  121         -
            object_1.key("FOO").string(inner.as_str());
         148  +
            /* SerializerUtil.kt:42 */
         149  +
            {
         150  +
                /* JsonSerializerGenerator.kt:423 */
         151  +
                object_1.key("FOO").string(inner.as_str());
         152  +
                /* SerializerUtil.kt:42 */
         153  +
            }
         154  +
            /* JsonSerializerGenerator.kt:564 */
  122    155   
        }
         156  +
        /* JsonSerializerGenerator.kt:564 */
  123    157   
        crate::model::UnionWithJsonName::Bar(inner) => {
  124         -
            object_1.key("bar").string(inner.as_str());
         158  +
            /* SerializerUtil.kt:42 */
         159  +
            {
         160  +
                /* JsonSerializerGenerator.kt:423 */
         161  +
                object_1.key("bar").string(inner.as_str());
         162  +
                /* SerializerUtil.kt:42 */
         163  +
            }
         164  +
            /* JsonSerializerGenerator.kt:564 */
  125    165   
        }
         166  +
        /* JsonSerializerGenerator.kt:564 */
  126    167   
        crate::model::UnionWithJsonName::Baz(inner) => {
  127         -
            object_1.key("_baz").string(inner.as_str());
         168  +
            /* SerializerUtil.kt:42 */
         169  +
            {
         170  +
                /* JsonSerializerGenerator.kt:423 */
         171  +
                object_1.key("_baz").string(inner.as_str());
         172  +
                /* SerializerUtil.kt:42 */
         173  +
            }
         174  +
            /* JsonSerializerGenerator.kt:564 */
  128    175   
        }
         176  +
        /* JsonSerializerGenerator.kt:556 */
  129    177   
    }
         178  +
    /* JsonSerializerGenerator.kt:576 */
  130    179   
    Ok(())
         180  +
    /* JsonSerializerGenerator.kt:547 */
  131    181   
}

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_unit_input_and_output.rs

@@ -1,1 +54,80 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* RustType.kt:534 */
    2      3   
#[allow(clippy::unnecessary_wraps)]
           4  +
/* ServerHttpBoundProtocolGenerator.kt:408 */
    3      5   
pub async fn de_unit_input_and_output_http_request<B>(
    4         -
    #[allow(unused_variables)] request: ::http::Request<B>,
           6  +
    #[allow(unused_variables)] request: ::http_1x::Request<B>,
    5      7   
) -> std::result::Result<
    6      8   
    crate::input::UnitInputAndOutputInput,
    7      9   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
    8     10   
>
    9     11   
where
   10     12   
    B: ::aws_smithy_http_server::body::HttpBody + Send,
   11     13   
    B::Data: Send,
   12     14   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
   13     15   
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
   14     16   
{
          17  +
    /* ServerHttpBoundProtocolGenerator.kt:424 */
   15     18   
    Ok({
          19  +
        /* RustType.kt:534 */
   16     20   
        #[allow(unused_mut)]
          21  +
        /* ServerHttpBoundProtocolGenerator.kt:759 */
   17     22   
        let mut input = crate::input::unit_input_and_output_input::Builder::default();
          23  +
        /* RustType.kt:534 */
   18     24   
        #[allow(unused_variables)]
          25  +
        /* ServerHttpBoundProtocolGenerator.kt:764 */
   19     26   
        let ::aws_smithy_runtime_api::http::RequestParts {
   20     27   
            uri, headers, body, ..
   21     28   
        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
          29  +
        /* ServerHttpBoundProtocolGenerator.kt:873 */
   22     30   
        ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(&headers, None)?;
          31  +
        /* ServerHttpBoundProtocolGenerator.kt:896 */
   23     32   
        input.build()
          33  +
        /* ServerHttpBoundProtocolGenerator.kt:424 */
   24     34   
    })
          35  +
    /* ServerHttpBoundProtocolGenerator.kt:408 */
   25     36   
}
   26     37   
          38  +
/* RustType.kt:534 */
   27     39   
#[allow(clippy::unnecessary_wraps)]
          40  +
/* ServerHttpBoundProtocolGenerator.kt:445 */
   28     41   
pub fn ser_unit_input_and_output_http_response(
   29     42   
    #[allow(unused_variables)] output: crate::output::UnitInputAndOutputOutput,
   30     43   
) -> std::result::Result<
   31     44   
    ::aws_smithy_http_server::response::Response,
   32     45   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
   33     46   
> {
          47  +
    /* ServerHttpBoundProtocolGenerator.kt:457 */
   34     48   
    Ok({
          49  +
        /* RustType.kt:534 */
   35     50   
        #[allow(unused_mut)]
   36         -
        let mut builder = ::http::Response::builder();
          51  +
        /* ServerHttpBoundProtocolGenerator.kt:547 */
          52  +
        let mut builder = ::http_1x::Response::builder();
          53  +
        /* ServerHttpBoundProtocolGenerator.kt:633 */
   37     54   
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
   38     55   
            builder,
   39         -
            ::http::header::CONTENT_TYPE,
          56  +
            ::http_1x::header::CONTENT_TYPE,
   40     57   
            "application/json",
   41     58   
        );
          59  +
        /* ServerHttpBoundProtocolGenerator.kt:718 */
   42     60   
        let http_status: u16 = 200;
   43     61   
        builder = builder.status(http_status);
   44         -
        let payload = "";
          62  +
        /* ServerHttpBoundProtocolGenerator.kt:597 */
          63  +
        let payload =
          64  +
            /* HttpBoundProtocolPayloadGenerator.kt:233 */""
          65  +
        /* ServerHttpBoundProtocolGenerator.kt:597 */;
          66  +
        /* ServerHttpBoundProtocolGenerator.kt:699 */
   45     67   
        let content_length = payload.len();
   46     68   
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
   47     69   
            builder,
   48         -
            ::http::header::CONTENT_LENGTH,
          70  +
            ::http_1x::header::CONTENT_LENGTH,
   49     71   
            content_length,
   50     72   
        );
          73  +
        /* ServerHttpBoundProtocolGenerator.kt:603 */
   51     74   
        let body = ::aws_smithy_http_server::body::to_boxed(payload);
          75  +
        /* ServerHttpBoundProtocolGenerator.kt:611 */
   52     76   
        builder.body(body)?
          77  +
        /* ServerHttpBoundProtocolGenerator.kt:457 */
   53     78   
    })
          79  +
    /* ServerHttpBoundProtocolGenerator.kt:445 */
   54     80   
}

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_validation_exception.rs

@@ -1,1 +35,58 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonSerializerGenerator.kt:213 */
    2      3   
pub fn ser_validation_exception_error(
    3      4   
    value: &crate::error::ValidationException,
    4      5   
) -> ::std::result::Result<String, ::aws_smithy_types::error::operation::SerializationError> {
           6  +
    /* JsonSerializerGenerator.kt:218 */
    5      7   
    let mut out = ::std::string::String::new();
    6      8   
    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
           9  +
    /* JsonSerializerGenerator.kt:375 */
    7     10   
    crate::protocol_serde::shape_validation_exception::ser_validation_exception(
    8     11   
        &mut object,
    9     12   
        value,
   10     13   
    )?;
          14  +
    /* JsonSerializerGenerator.kt:227 */
   11     15   
    object.finish();
   12     16   
    Ok(out)
          17  +
    /* JsonSerializerGenerator.kt:213 */
   13     18   
}
   14     19   
          20  +
/* JsonSerializerGenerator.kt:358 */
   15     21   
pub fn ser_validation_exception(
   16     22   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
   17     23   
    input: &crate::error::ValidationException,
   18     24   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
          25  +
    /* JsonSerializerGenerator.kt:382 */
   19     26   
    if let Some(var_1) = &input.field_list {
          27  +
        /* JsonSerializerGenerator.kt:484 */
   20     28   
        let mut array_2 = object.key("fieldList").start_array();
          29  +
        /* JsonSerializerGenerator.kt:524 */
   21     30   
        for item_3 in var_1 {
          31  +
            /* SerializerUtil.kt:42 */
   22     32   
            {
          33  +
                /* JsonSerializerGenerator.kt:495 */
   23     34   
                #[allow(unused_mut)]
          35  +
                /* JsonSerializerGenerator.kt:496 */
   24     36   
                let mut object_4 = array_2.value().start_object();
          37  +
                /* JsonSerializerGenerator.kt:375 */
   25     38   
                crate::protocol_serde::shape_validation_exception_field::ser_validation_exception_field(&mut object_4, item_3)?;
          39  +
                /* JsonSerializerGenerator.kt:515 */
   26     40   
                object_4.finish();
          41  +
                /* SerializerUtil.kt:42 */
   27     42   
            }
          43  +
            /* JsonSerializerGenerator.kt:524 */
   28     44   
        }
          45  +
        /* JsonSerializerGenerator.kt:486 */
   29     46   
        array_2.finish();
          47  +
        /* JsonSerializerGenerator.kt:382 */
   30     48   
    }
          49  +
    /* SerializerUtil.kt:42 */
   31     50   
    {
          51  +
        /* JsonSerializerGenerator.kt:423 */
   32     52   
        object.key("message").string(input.message.as_str());
          53  +
        /* SerializerUtil.kt:42 */
   33     54   
    }
          55  +
    /* JsonSerializerGenerator.kt:372 */
   34     56   
    Ok(())
          57  +
    /* JsonSerializerGenerator.kt:358 */
   35     58   
}

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_validation_exception_field.rs

@@ -1,1 +13,22 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonSerializerGenerator.kt:358 */
    2      3   
pub fn ser_validation_exception_field(
    3      4   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
    4      5   
    input: &crate::model::ValidationExceptionField,
    5      6   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
           7  +
    /* SerializerUtil.kt:42 */
    6      8   
    {
           9  +
        /* JsonSerializerGenerator.kt:423 */
    7     10   
        object.key("path").string(input.path.as_str());
          11  +
        /* SerializerUtil.kt:42 */
    8     12   
    }
          13  +
    /* SerializerUtil.kt:42 */
    9     14   
    {
          15  +
        /* JsonSerializerGenerator.kt:423 */
   10     16   
        object.key("message").string(input.message.as_str());
          17  +
        /* SerializerUtil.kt:42 */
   11     18   
    }
          19  +
    /* JsonSerializerGenerator.kt:372 */
   12     20   
    Ok(())
          21  +
    /* JsonSerializerGenerator.kt:358 */
   13     22   
}

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/service.rs

@@ -1,1 +31,32 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* ServerServiceGenerator.kt:795 */
    2      3   
/// The service builder for [`RestJson`].
    3      4   
///
    4      5   
/// Constructed via [`RestJson::builder`].
    5      6   
pub struct RestJsonBuilder<Body, L, HttpPl, ModelPl> {
    6      7   
    all_query_string_types: Option<::aws_smithy_http_server::routing::Route<Body>>,
    7      8   
    constant_and_variable_query_string: Option<::aws_smithy_http_server::routing::Route<Body>>,
    8      9   
    constant_query_string: Option<::aws_smithy_http_server::routing::Route<Body>>,
    9     10   
    content_type_parameters: Option<::aws_smithy_http_server::routing::Route<Body>>,
   10     11   
    datetime_offsets: Option<::aws_smithy_http_server::routing::Route<Body>>,
   11     12   
    document_type: Option<::aws_smithy_http_server::routing::Route<Body>>,
@@ -142,143 +203,204 @@
  162    163   
                            <
  163    164   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  164    165   
                                as ::aws_smithy_http_server::plugin::Plugin<
  165    166   
                                    RestJson<L>,
  166    167   
                                    crate::operation_shape::AllQueryStringTypes,
  167    168   
                                    ModelPl::Output
  168    169   
                                >
  169    170   
                            >::Output
  170    171   
                        >,
  171    172   
  172         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  173         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         173  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         174  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  174    175   
  175    176   
                    {
  176    177   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  177    178   
        use ::aws_smithy_http_server::plugin::Plugin;
  178    179   
        let svc = crate::operation_shape::AllQueryStringTypes::from_handler(handler);
  179    180   
        let svc = self.model_plugin.apply(svc);
  180    181   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  181    182   
            .apply(svc);
  182    183   
        let svc = self.http_plugin.apply(svc);
  183    184   
        self.all_query_string_types_custom(svc)
@@ -209,210 +289,290 @@
  229    230   
                            <
  230    231   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  231    232   
                                as ::aws_smithy_http_server::plugin::Plugin<
  232    233   
                                    RestJson<L>,
  233    234   
                                    crate::operation_shape::AllQueryStringTypes,
  234    235   
                                    ModelPl::Output
  235    236   
                                >
  236    237   
                            >::Output
  237    238   
                        >,
  238    239   
  239         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  240         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         240  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         241  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  241    242   
  242    243   
                    {
  243    244   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  244    245   
        use ::aws_smithy_http_server::plugin::Plugin;
  245    246   
        let svc = crate::operation_shape::AllQueryStringTypes::from_service(service);
  246    247   
        let svc = self.model_plugin.apply(svc);
  247    248   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  248    249   
            .apply(svc);
  249    250   
        let svc = self.http_plugin.apply(svc);
  250    251   
        self.all_query_string_types_custom(svc)
  251    252   
    }
  252    253   
  253    254   
    /// Sets the [`AllQueryStringTypes`](crate::operation_shape::AllQueryStringTypes) to a custom [`Service`](tower::Service).
  254    255   
    /// not constrained by the Smithy contract.
  255    256   
    fn all_query_string_types_custom<S>(mut self, svc: S) -> Self
  256    257   
    where
  257    258   
        S: ::tower::Service<
  258         -
                ::http::Request<Body>,
  259         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
         259  +
                ::http_1x::Request<Body>,
         260  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
  260    261   
                Error = ::std::convert::Infallible,
  261    262   
            > + Clone
  262    263   
            + Send
  263    264   
            + 'static,
  264    265   
        S::Future: Send + 'static,
  265    266   
    {
  266    267   
        self.all_query_string_types = Some(::aws_smithy_http_server::routing::Route::new(svc));
  267    268   
        self
  268    269   
    }
  269    270
@@ -292,293 +353,354 @@
  312    313   
                            <
  313    314   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  314    315   
                                as ::aws_smithy_http_server::plugin::Plugin<
  315    316   
                                    RestJson<L>,
  316    317   
                                    crate::operation_shape::ConstantAndVariableQueryString,
  317    318   
                                    ModelPl::Output
  318    319   
                                >
  319    320   
                            >::Output
  320    321   
                        >,
  321    322   
  322         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  323         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         323  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         324  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  324    325   
  325    326   
                    {
  326    327   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  327    328   
        use ::aws_smithy_http_server::plugin::Plugin;
  328    329   
        let svc = crate::operation_shape::ConstantAndVariableQueryString::from_handler(handler);
  329    330   
        let svc = self.model_plugin.apply(svc);
  330    331   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  331    332   
            .apply(svc);
  332    333   
        let svc = self.http_plugin.apply(svc);
  333    334   
        self.constant_and_variable_query_string_custom(svc)
@@ -359,360 +439,440 @@
  379    380   
                            <
  380    381   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  381    382   
                                as ::aws_smithy_http_server::plugin::Plugin<
  382    383   
                                    RestJson<L>,
  383    384   
                                    crate::operation_shape::ConstantAndVariableQueryString,
  384    385   
                                    ModelPl::Output
  385    386   
                                >
  386    387   
                            >::Output
  387    388   
                        >,
  388    389   
  389         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  390         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         390  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         391  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  391    392   
  392    393   
                    {
  393    394   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  394    395   
        use ::aws_smithy_http_server::plugin::Plugin;
  395    396   
        let svc = crate::operation_shape::ConstantAndVariableQueryString::from_service(service);
  396    397   
        let svc = self.model_plugin.apply(svc);
  397    398   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  398    399   
            .apply(svc);
  399    400   
        let svc = self.http_plugin.apply(svc);
  400    401   
        self.constant_and_variable_query_string_custom(svc)
  401    402   
    }
  402    403   
  403    404   
    /// Sets the [`ConstantAndVariableQueryString`](crate::operation_shape::ConstantAndVariableQueryString) to a custom [`Service`](tower::Service).
  404    405   
    /// not constrained by the Smithy contract.
  405    406   
    fn constant_and_variable_query_string_custom<S>(mut self, svc: S) -> Self
  406    407   
    where
  407    408   
        S: ::tower::Service<
  408         -
                ::http::Request<Body>,
  409         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
         409  +
                ::http_1x::Request<Body>,
         410  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
  410    411   
                Error = ::std::convert::Infallible,
  411    412   
            > + Clone
  412    413   
            + Send
  413    414   
            + 'static,
  414    415   
        S::Future: Send + 'static,
  415    416   
    {
  416    417   
        self.constant_and_variable_query_string =
  417    418   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
  418    419   
        self
  419    420   
    }
@@ -443,444 +504,505 @@
  463    464   
                            <
  464    465   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  465    466   
                                as ::aws_smithy_http_server::plugin::Plugin<
  466    467   
                                    RestJson<L>,
  467    468   
                                    crate::operation_shape::ConstantQueryString,
  468    469   
                                    ModelPl::Output
  469    470   
                                >
  470    471   
                            >::Output
  471    472   
                        >,
  472    473   
  473         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  474         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         474  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         475  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  475    476   
  476    477   
                    {
  477    478   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  478    479   
        use ::aws_smithy_http_server::plugin::Plugin;
  479    480   
        let svc = crate::operation_shape::ConstantQueryString::from_handler(handler);
  480    481   
        let svc = self.model_plugin.apply(svc);
  481    482   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  482    483   
            .apply(svc);
  483    484   
        let svc = self.http_plugin.apply(svc);
  484    485   
        self.constant_query_string_custom(svc)
@@ -510,511 +590,591 @@
  530    531   
                            <
  531    532   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  532    533   
                                as ::aws_smithy_http_server::plugin::Plugin<
  533    534   
                                    RestJson<L>,
  534    535   
                                    crate::operation_shape::ConstantQueryString,
  535    536   
                                    ModelPl::Output
  536    537   
                                >
  537    538   
                            >::Output
  538    539   
                        >,
  539    540   
  540         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  541         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         541  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         542  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  542    543   
  543    544   
                    {
  544    545   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  545    546   
        use ::aws_smithy_http_server::plugin::Plugin;
  546    547   
        let svc = crate::operation_shape::ConstantQueryString::from_service(service);
  547    548   
        let svc = self.model_plugin.apply(svc);
  548    549   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  549    550   
            .apply(svc);
  550    551   
        let svc = self.http_plugin.apply(svc);
  551    552   
        self.constant_query_string_custom(svc)
  552    553   
    }
  553    554   
  554    555   
    /// Sets the [`ConstantQueryString`](crate::operation_shape::ConstantQueryString) to a custom [`Service`](tower::Service).
  555    556   
    /// not constrained by the Smithy contract.
  556    557   
    fn constant_query_string_custom<S>(mut self, svc: S) -> Self
  557    558   
    where
  558    559   
        S: ::tower::Service<
  559         -
                ::http::Request<Body>,
  560         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
         560  +
                ::http_1x::Request<Body>,
         561  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
  561    562   
                Error = ::std::convert::Infallible,
  562    563   
            > + Clone
  563    564   
            + Send
  564    565   
            + 'static,
  565    566   
        S::Future: Send + 'static,
  566    567   
    {
  567    568   
        self.constant_query_string = Some(::aws_smithy_http_server::routing::Route::new(svc));
  568    569   
        self
  569    570   
    }
  570    571
@@ -593,594 +654,655 @@
  613    614   
                            <
  614    615   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  615    616   
                                as ::aws_smithy_http_server::plugin::Plugin<
  616    617   
                                    RestJson<L>,
  617    618   
                                    crate::operation_shape::ContentTypeParameters,
  618    619   
                                    ModelPl::Output
  619    620   
                                >
  620    621   
                            >::Output
  621    622   
                        >,
  622    623   
  623         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  624         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         624  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         625  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  625    626   
  626    627   
                    {
  627    628   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  628    629   
        use ::aws_smithy_http_server::plugin::Plugin;
  629    630   
        let svc = crate::operation_shape::ContentTypeParameters::from_handler(handler);
  630    631   
        let svc = self.model_plugin.apply(svc);
  631    632   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  632    633   
            .apply(svc);
  633    634   
        let svc = self.http_plugin.apply(svc);
  634    635   
        self.content_type_parameters_custom(svc)
@@ -660,661 +740,741 @@
  680    681   
                            <
  681    682   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  682    683   
                                as ::aws_smithy_http_server::plugin::Plugin<
  683    684   
                                    RestJson<L>,
  684    685   
                                    crate::operation_shape::ContentTypeParameters,
  685    686   
                                    ModelPl::Output
  686    687   
                                >
  687    688   
                            >::Output
  688    689   
                        >,
  689    690   
  690         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  691         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         691  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         692  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  692    693   
  693    694   
                    {
  694    695   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  695    696   
        use ::aws_smithy_http_server::plugin::Plugin;
  696    697   
        let svc = crate::operation_shape::ContentTypeParameters::from_service(service);
  697    698   
        let svc = self.model_plugin.apply(svc);
  698    699   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  699    700   
            .apply(svc);
  700    701   
        let svc = self.http_plugin.apply(svc);
  701    702   
        self.content_type_parameters_custom(svc)
  702    703   
    }
  703    704   
  704    705   
    /// Sets the [`ContentTypeParameters`](crate::operation_shape::ContentTypeParameters) to a custom [`Service`](tower::Service).
  705    706   
    /// not constrained by the Smithy contract.
  706    707   
    fn content_type_parameters_custom<S>(mut self, svc: S) -> Self
  707    708   
    where
  708    709   
        S: ::tower::Service<
  709         -
                ::http::Request<Body>,
  710         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
         710  +
                ::http_1x::Request<Body>,
         711  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
  711    712   
                Error = ::std::convert::Infallible,
  712    713   
            > + Clone
  713    714   
            + Send
  714    715   
            + 'static,
  715    716   
        S::Future: Send + 'static,
  716    717   
    {
  717    718   
        self.content_type_parameters = Some(::aws_smithy_http_server::routing::Route::new(svc));
  718    719   
        self
  719    720   
    }
  720    721
@@ -743,744 +804,805 @@
  763    764   
                            <
  764    765   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  765    766   
                                as ::aws_smithy_http_server::plugin::Plugin<
  766    767   
                                    RestJson<L>,
  767    768   
                                    crate::operation_shape::DatetimeOffsets,
  768    769   
                                    ModelPl::Output
  769    770   
                                >
  770    771   
                            >::Output
  771    772   
                        >,
  772    773   
  773         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  774         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         774  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         775  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  775    776   
  776    777   
                    {
  777    778   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  778    779   
        use ::aws_smithy_http_server::plugin::Plugin;
  779    780   
        let svc = crate::operation_shape::DatetimeOffsets::from_handler(handler);
  780    781   
        let svc = self.model_plugin.apply(svc);
  781    782   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  782    783   
            .apply(svc);
  783    784   
        let svc = self.http_plugin.apply(svc);
  784    785   
        self.datetime_offsets_custom(svc)
@@ -810,811 +890,891 @@
  830    831   
                            <
  831    832   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  832    833   
                                as ::aws_smithy_http_server::plugin::Plugin<
  833    834   
                                    RestJson<L>,
  834    835   
                                    crate::operation_shape::DatetimeOffsets,
  835    836   
                                    ModelPl::Output
  836    837   
                                >
  837    838   
                            >::Output
  838    839   
                        >,
  839    840   
  840         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  841         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         841  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         842  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  842    843   
  843    844   
                    {
  844    845   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  845    846   
        use ::aws_smithy_http_server::plugin::Plugin;
  846    847   
        let svc = crate::operation_shape::DatetimeOffsets::from_service(service);
  847    848   
        let svc = self.model_plugin.apply(svc);
  848    849   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  849    850   
            .apply(svc);
  850    851   
        let svc = self.http_plugin.apply(svc);
  851    852   
        self.datetime_offsets_custom(svc)
  852    853   
    }
  853    854   
  854    855   
    /// Sets the [`DatetimeOffsets`](crate::operation_shape::DatetimeOffsets) to a custom [`Service`](tower::Service).
  855    856   
    /// not constrained by the Smithy contract.
  856    857   
    fn datetime_offsets_custom<S>(mut self, svc: S) -> Self
  857    858   
    where
  858    859   
        S: ::tower::Service<
  859         -
                ::http::Request<Body>,
  860         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
         860  +
                ::http_1x::Request<Body>,
         861  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
  861    862   
                Error = ::std::convert::Infallible,
  862    863   
            > + Clone
  863    864   
            + Send
  864    865   
            + 'static,
  865    866   
        S::Future: Send + 'static,
  866    867   
    {
  867    868   
        self.datetime_offsets = Some(::aws_smithy_http_server::routing::Route::new(svc));
  868    869   
        self
  869    870   
    }
  870    871
@@ -893,894 +954,955 @@
  913    914   
                            <
  914    915   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  915    916   
                                as ::aws_smithy_http_server::plugin::Plugin<
  916    917   
                                    RestJson<L>,
  917    918   
                                    crate::operation_shape::DocumentType,
  918    919   
                                    ModelPl::Output
  919    920   
                                >
  920    921   
                            >::Output
  921    922   
                        >,
  922    923   
  923         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  924         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         924  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         925  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  925    926   
  926    927   
                    {
  927    928   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  928    929   
        use ::aws_smithy_http_server::plugin::Plugin;
  929    930   
        let svc = crate::operation_shape::DocumentType::from_handler(handler);
  930    931   
        let svc = self.model_plugin.apply(svc);
  931    932   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  932    933   
            .apply(svc);
  933    934   
        let svc = self.http_plugin.apply(svc);
  934    935   
        self.document_type_custom(svc)
@@ -960,961 +1040,1041 @@
  980    981   
                            <
  981    982   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
  982    983   
                                as ::aws_smithy_http_server::plugin::Plugin<
  983    984   
                                    RestJson<L>,
  984    985   
                                    crate::operation_shape::DocumentType,
  985    986   
                                    ModelPl::Output
  986    987   
                                >
  987    988   
                            >::Output
  988    989   
                        >,
  989    990   
  990         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
  991         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         991  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         992  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
  992    993   
  993    994   
                    {
  994    995   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
  995    996   
        use ::aws_smithy_http_server::plugin::Plugin;
  996    997   
        let svc = crate::operation_shape::DocumentType::from_service(service);
  997    998   
        let svc = self.model_plugin.apply(svc);
  998    999   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
  999   1000   
            .apply(svc);
 1000   1001   
        let svc = self.http_plugin.apply(svc);
 1001   1002   
        self.document_type_custom(svc)
 1002   1003   
    }
 1003   1004   
 1004   1005   
    /// Sets the [`DocumentType`](crate::operation_shape::DocumentType) to a custom [`Service`](tower::Service).
 1005   1006   
    /// not constrained by the Smithy contract.
 1006   1007   
    fn document_type_custom<S>(mut self, svc: S) -> Self
 1007   1008   
    where
 1008   1009   
        S: ::tower::Service<
 1009         -
                ::http::Request<Body>,
 1010         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1010  +
                ::http_1x::Request<Body>,
        1011  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1011   1012   
                Error = ::std::convert::Infallible,
 1012   1013   
            > + Clone
 1013   1014   
            + Send
 1014   1015   
            + 'static,
 1015   1016   
        S::Future: Send + 'static,
 1016   1017   
    {
 1017   1018   
        self.document_type = Some(::aws_smithy_http_server::routing::Route::new(svc));
 1018   1019   
        self
 1019   1020   
    }
 1020   1021
@@ -1043,1044 +1104,1105 @@
 1063   1064   
                            <
 1064   1065   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1065   1066   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1066   1067   
                                    RestJson<L>,
 1067   1068   
                                    crate::operation_shape::DocumentTypeAsMapValue,
 1068   1069   
                                    ModelPl::Output
 1069   1070   
                                >
 1070   1071   
                            >::Output
 1071   1072   
                        >,
 1072   1073   
 1073         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1074         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1074  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1075  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1075   1076   
 1076   1077   
                    {
 1077   1078   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1078   1079   
        use ::aws_smithy_http_server::plugin::Plugin;
 1079   1080   
        let svc = crate::operation_shape::DocumentTypeAsMapValue::from_handler(handler);
 1080   1081   
        let svc = self.model_plugin.apply(svc);
 1081   1082   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1082   1083   
            .apply(svc);
 1083   1084   
        let svc = self.http_plugin.apply(svc);
 1084   1085   
        self.document_type_as_map_value_custom(svc)
@@ -1110,1111 +1190,1191 @@
 1130   1131   
                            <
 1131   1132   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1132   1133   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1133   1134   
                                    RestJson<L>,
 1134   1135   
                                    crate::operation_shape::DocumentTypeAsMapValue,
 1135   1136   
                                    ModelPl::Output
 1136   1137   
                                >
 1137   1138   
                            >::Output
 1138   1139   
                        >,
 1139   1140   
 1140         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1141         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1141  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1142  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1142   1143   
 1143   1144   
                    {
 1144   1145   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1145   1146   
        use ::aws_smithy_http_server::plugin::Plugin;
 1146   1147   
        let svc = crate::operation_shape::DocumentTypeAsMapValue::from_service(service);
 1147   1148   
        let svc = self.model_plugin.apply(svc);
 1148   1149   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1149   1150   
            .apply(svc);
 1150   1151   
        let svc = self.http_plugin.apply(svc);
 1151   1152   
        self.document_type_as_map_value_custom(svc)
 1152   1153   
    }
 1153   1154   
 1154   1155   
    /// Sets the [`DocumentTypeAsMapValue`](crate::operation_shape::DocumentTypeAsMapValue) to a custom [`Service`](tower::Service).
 1155   1156   
    /// not constrained by the Smithy contract.
 1156   1157   
    fn document_type_as_map_value_custom<S>(mut self, svc: S) -> Self
 1157   1158   
    where
 1158   1159   
        S: ::tower::Service<
 1159         -
                ::http::Request<Body>,
 1160         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1160  +
                ::http_1x::Request<Body>,
        1161  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1161   1162   
                Error = ::std::convert::Infallible,
 1162   1163   
            > + Clone
 1163   1164   
            + Send
 1164   1165   
            + 'static,
 1165   1166   
        S::Future: Send + 'static,
 1166   1167   
    {
 1167   1168   
        self.document_type_as_map_value = Some(::aws_smithy_http_server::routing::Route::new(svc));
 1168   1169   
        self
 1169   1170   
    }
 1170   1171
@@ -1193,1194 +1254,1255 @@
 1213   1214   
                            <
 1214   1215   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1215   1216   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1216   1217   
                                    RestJson<L>,
 1217   1218   
                                    crate::operation_shape::DocumentTypeAsPayload,
 1218   1219   
                                    ModelPl::Output
 1219   1220   
                                >
 1220   1221   
                            >::Output
 1221   1222   
                        >,
 1222   1223   
 1223         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1224         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1224  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1225  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1225   1226   
 1226   1227   
                    {
 1227   1228   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1228   1229   
        use ::aws_smithy_http_server::plugin::Plugin;
 1229   1230   
        let svc = crate::operation_shape::DocumentTypeAsPayload::from_handler(handler);
 1230   1231   
        let svc = self.model_plugin.apply(svc);
 1231   1232   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1232   1233   
            .apply(svc);
 1233   1234   
        let svc = self.http_plugin.apply(svc);
 1234   1235   
        self.document_type_as_payload_custom(svc)
@@ -1260,1261 +1340,1341 @@
 1280   1281   
                            <
 1281   1282   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1282   1283   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1283   1284   
                                    RestJson<L>,
 1284   1285   
                                    crate::operation_shape::DocumentTypeAsPayload,
 1285   1286   
                                    ModelPl::Output
 1286   1287   
                                >
 1287   1288   
                            >::Output
 1288   1289   
                        >,
 1289   1290   
 1290         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1291         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1291  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1292  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1292   1293   
 1293   1294   
                    {
 1294   1295   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1295   1296   
        use ::aws_smithy_http_server::plugin::Plugin;
 1296   1297   
        let svc = crate::operation_shape::DocumentTypeAsPayload::from_service(service);
 1297   1298   
        let svc = self.model_plugin.apply(svc);
 1298   1299   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1299   1300   
            .apply(svc);
 1300   1301   
        let svc = self.http_plugin.apply(svc);
 1301   1302   
        self.document_type_as_payload_custom(svc)
 1302   1303   
    }
 1303   1304   
 1304   1305   
    /// Sets the [`DocumentTypeAsPayload`](crate::operation_shape::DocumentTypeAsPayload) to a custom [`Service`](tower::Service).
 1305   1306   
    /// not constrained by the Smithy contract.
 1306   1307   
    fn document_type_as_payload_custom<S>(mut self, svc: S) -> Self
 1307   1308   
    where
 1308   1309   
        S: ::tower::Service<
 1309         -
                ::http::Request<Body>,
 1310         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1310  +
                ::http_1x::Request<Body>,
        1311  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1311   1312   
                Error = ::std::convert::Infallible,
 1312   1313   
            > + Clone
 1313   1314   
            + Send
 1314   1315   
            + 'static,
 1315   1316   
        S::Future: Send + 'static,
 1316   1317   
    {
 1317   1318   
        self.document_type_as_payload = Some(::aws_smithy_http_server::routing::Route::new(svc));
 1318   1319   
        self
 1319   1320   
    }
 1320   1321
@@ -1343,1344 +1404,1405 @@
 1363   1364   
                            <
 1364   1365   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1365   1366   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1366   1367   
                                    RestJson<L>,
 1367   1368   
                                    crate::operation_shape::EmptyInputAndEmptyOutput,
 1368   1369   
                                    ModelPl::Output
 1369   1370   
                                >
 1370   1371   
                            >::Output
 1371   1372   
                        >,
 1372   1373   
 1373         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1374         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1374  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1375  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1375   1376   
 1376   1377   
                    {
 1377   1378   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1378   1379   
        use ::aws_smithy_http_server::plugin::Plugin;
 1379   1380   
        let svc = crate::operation_shape::EmptyInputAndEmptyOutput::from_handler(handler);
 1380   1381   
        let svc = self.model_plugin.apply(svc);
 1381   1382   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1382   1383   
            .apply(svc);
 1383   1384   
        let svc = self.http_plugin.apply(svc);
 1384   1385   
        self.empty_input_and_empty_output_custom(svc)
@@ -1410,1411 +1490,1491 @@
 1430   1431   
                            <
 1431   1432   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1432   1433   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1433   1434   
                                    RestJson<L>,
 1434   1435   
                                    crate::operation_shape::EmptyInputAndEmptyOutput,
 1435   1436   
                                    ModelPl::Output
 1436   1437   
                                >
 1437   1438   
                            >::Output
 1438   1439   
                        >,
 1439   1440   
 1440         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1441         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1441  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1442  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1442   1443   
 1443   1444   
                    {
 1444   1445   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1445   1446   
        use ::aws_smithy_http_server::plugin::Plugin;
 1446   1447   
        let svc = crate::operation_shape::EmptyInputAndEmptyOutput::from_service(service);
 1447   1448   
        let svc = self.model_plugin.apply(svc);
 1448   1449   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1449   1450   
            .apply(svc);
 1450   1451   
        let svc = self.http_plugin.apply(svc);
 1451   1452   
        self.empty_input_and_empty_output_custom(svc)
 1452   1453   
    }
 1453   1454   
 1454   1455   
    /// Sets the [`EmptyInputAndEmptyOutput`](crate::operation_shape::EmptyInputAndEmptyOutput) to a custom [`Service`](tower::Service).
 1455   1456   
    /// not constrained by the Smithy contract.
 1456   1457   
    fn empty_input_and_empty_output_custom<S>(mut self, svc: S) -> Self
 1457   1458   
    where
 1458   1459   
        S: ::tower::Service<
 1459         -
                ::http::Request<Body>,
 1460         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1460  +
                ::http_1x::Request<Body>,
        1461  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1461   1462   
                Error = ::std::convert::Infallible,
 1462   1463   
            > + Clone
 1463   1464   
            + Send
 1464   1465   
            + 'static,
 1465   1466   
        S::Future: Send + 'static,
 1466   1467   
    {
 1467   1468   
        self.empty_input_and_empty_output =
 1468   1469   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 1469   1470   
        self
 1470   1471   
    }
@@ -1494,1495 +1555,1556 @@
 1514   1515   
                            <
 1515   1516   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1516   1517   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1517   1518   
                                    RestJson<L>,
 1518   1519   
                                    crate::operation_shape::EndpointOperation,
 1519   1520   
                                    ModelPl::Output
 1520   1521   
                                >
 1521   1522   
                            >::Output
 1522   1523   
                        >,
 1523   1524   
 1524         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1525         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1525  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1526  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1526   1527   
 1527   1528   
                    {
 1528   1529   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1529   1530   
        use ::aws_smithy_http_server::plugin::Plugin;
 1530   1531   
        let svc = crate::operation_shape::EndpointOperation::from_handler(handler);
 1531   1532   
        let svc = self.model_plugin.apply(svc);
 1532   1533   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1533   1534   
            .apply(svc);
 1534   1535   
        let svc = self.http_plugin.apply(svc);
 1535   1536   
        self.endpoint_operation_custom(svc)
@@ -1561,1562 +1641,1642 @@
 1581   1582   
                            <
 1582   1583   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1583   1584   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1584   1585   
                                    RestJson<L>,
 1585   1586   
                                    crate::operation_shape::EndpointOperation,
 1586   1587   
                                    ModelPl::Output
 1587   1588   
                                >
 1588   1589   
                            >::Output
 1589   1590   
                        >,
 1590   1591   
 1591         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1592         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1592  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1593  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1593   1594   
 1594   1595   
                    {
 1595   1596   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1596   1597   
        use ::aws_smithy_http_server::plugin::Plugin;
 1597   1598   
        let svc = crate::operation_shape::EndpointOperation::from_service(service);
 1598   1599   
        let svc = self.model_plugin.apply(svc);
 1599   1600   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1600   1601   
            .apply(svc);
 1601   1602   
        let svc = self.http_plugin.apply(svc);
 1602   1603   
        self.endpoint_operation_custom(svc)
 1603   1604   
    }
 1604   1605   
 1605   1606   
    /// Sets the [`EndpointOperation`](crate::operation_shape::EndpointOperation) to a custom [`Service`](tower::Service).
 1606   1607   
    /// not constrained by the Smithy contract.
 1607   1608   
    fn endpoint_operation_custom<S>(mut self, svc: S) -> Self
 1608   1609   
    where
 1609   1610   
        S: ::tower::Service<
 1610         -
                ::http::Request<Body>,
 1611         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1611  +
                ::http_1x::Request<Body>,
        1612  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1612   1613   
                Error = ::std::convert::Infallible,
 1613   1614   
            > + Clone
 1614   1615   
            + Send
 1615   1616   
            + 'static,
 1616   1617   
        S::Future: Send + 'static,
 1617   1618   
    {
 1618   1619   
        self.endpoint_operation = Some(::aws_smithy_http_server::routing::Route::new(svc));
 1619   1620   
        self
 1620   1621   
    }
 1621   1622
@@ -1644,1645 +1705,1706 @@
 1664   1665   
                            <
 1665   1666   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1666   1667   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1667   1668   
                                    RestJson<L>,
 1668   1669   
                                    crate::operation_shape::EndpointWithHostLabelOperation,
 1669   1670   
                                    ModelPl::Output
 1670   1671   
                                >
 1671   1672   
                            >::Output
 1672   1673   
                        >,
 1673   1674   
 1674         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1675         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1675  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1676  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1676   1677   
 1677   1678   
                    {
 1678   1679   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1679   1680   
        use ::aws_smithy_http_server::plugin::Plugin;
 1680   1681   
        let svc = crate::operation_shape::EndpointWithHostLabelOperation::from_handler(handler);
 1681   1682   
        let svc = self.model_plugin.apply(svc);
 1682   1683   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1683   1684   
            .apply(svc);
 1684   1685   
        let svc = self.http_plugin.apply(svc);
 1685   1686   
        self.endpoint_with_host_label_operation_custom(svc)
@@ -1711,1712 +1791,1792 @@
 1731   1732   
                            <
 1732   1733   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1733   1734   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1734   1735   
                                    RestJson<L>,
 1735   1736   
                                    crate::operation_shape::EndpointWithHostLabelOperation,
 1736   1737   
                                    ModelPl::Output
 1737   1738   
                                >
 1738   1739   
                            >::Output
 1739   1740   
                        >,
 1740   1741   
 1741         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1742         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1742  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1743  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1743   1744   
 1744   1745   
                    {
 1745   1746   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1746   1747   
        use ::aws_smithy_http_server::plugin::Plugin;
 1747   1748   
        let svc = crate::operation_shape::EndpointWithHostLabelOperation::from_service(service);
 1748   1749   
        let svc = self.model_plugin.apply(svc);
 1749   1750   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1750   1751   
            .apply(svc);
 1751   1752   
        let svc = self.http_plugin.apply(svc);
 1752   1753   
        self.endpoint_with_host_label_operation_custom(svc)
 1753   1754   
    }
 1754   1755   
 1755   1756   
    /// Sets the [`EndpointWithHostLabelOperation`](crate::operation_shape::EndpointWithHostLabelOperation) to a custom [`Service`](tower::Service).
 1756   1757   
    /// not constrained by the Smithy contract.
 1757   1758   
    fn endpoint_with_host_label_operation_custom<S>(mut self, svc: S) -> Self
 1758   1759   
    where
 1759   1760   
        S: ::tower::Service<
 1760         -
                ::http::Request<Body>,
 1761         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1761  +
                ::http_1x::Request<Body>,
        1762  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1762   1763   
                Error = ::std::convert::Infallible,
 1763   1764   
            > + Clone
 1764   1765   
            + Send
 1765   1766   
            + 'static,
 1766   1767   
        S::Future: Send + 'static,
 1767   1768   
    {
 1768   1769   
        self.endpoint_with_host_label_operation =
 1769   1770   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 1770   1771   
        self
 1771   1772   
    }
@@ -1795,1796 +1856,1857 @@
 1815   1816   
                            <
 1816   1817   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1817   1818   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1818   1819   
                                    RestJson<L>,
 1819   1820   
                                    crate::operation_shape::FractionalSeconds,
 1820   1821   
                                    ModelPl::Output
 1821   1822   
                                >
 1822   1823   
                            >::Output
 1823   1824   
                        >,
 1824   1825   
 1825         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1826         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1826  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1827  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1827   1828   
 1828   1829   
                    {
 1829   1830   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1830   1831   
        use ::aws_smithy_http_server::plugin::Plugin;
 1831   1832   
        let svc = crate::operation_shape::FractionalSeconds::from_handler(handler);
 1832   1833   
        let svc = self.model_plugin.apply(svc);
 1833   1834   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1834   1835   
            .apply(svc);
 1835   1836   
        let svc = self.http_plugin.apply(svc);
 1836   1837   
        self.fractional_seconds_custom(svc)
@@ -1862,1863 +1942,1943 @@
 1882   1883   
                            <
 1883   1884   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1884   1885   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1885   1886   
                                    RestJson<L>,
 1886   1887   
                                    crate::operation_shape::FractionalSeconds,
 1887   1888   
                                    ModelPl::Output
 1888   1889   
                                >
 1889   1890   
                            >::Output
 1890   1891   
                        >,
 1891   1892   
 1892         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1893         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1893  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1894  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1894   1895   
 1895   1896   
                    {
 1896   1897   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1897   1898   
        use ::aws_smithy_http_server::plugin::Plugin;
 1898   1899   
        let svc = crate::operation_shape::FractionalSeconds::from_service(service);
 1899   1900   
        let svc = self.model_plugin.apply(svc);
 1900   1901   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1901   1902   
            .apply(svc);
 1902   1903   
        let svc = self.http_plugin.apply(svc);
 1903   1904   
        self.fractional_seconds_custom(svc)
 1904   1905   
    }
 1905   1906   
 1906   1907   
    /// Sets the [`FractionalSeconds`](crate::operation_shape::FractionalSeconds) to a custom [`Service`](tower::Service).
 1907   1908   
    /// not constrained by the Smithy contract.
 1908   1909   
    fn fractional_seconds_custom<S>(mut self, svc: S) -> Self
 1909   1910   
    where
 1910   1911   
        S: ::tower::Service<
 1911         -
                ::http::Request<Body>,
 1912         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        1912  +
                ::http_1x::Request<Body>,
        1913  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 1913   1914   
                Error = ::std::convert::Infallible,
 1914   1915   
            > + Clone
 1915   1916   
            + Send
 1916   1917   
            + 'static,
 1917   1918   
        S::Future: Send + 'static,
 1918   1919   
    {
 1919   1920   
        self.fractional_seconds = Some(::aws_smithy_http_server::routing::Route::new(svc));
 1920   1921   
        self
 1921   1922   
    }
 1922   1923
@@ -1945,1946 +2006,2007 @@
 1965   1966   
                            <
 1966   1967   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 1967   1968   
                                as ::aws_smithy_http_server::plugin::Plugin<
 1968   1969   
                                    RestJson<L>,
 1969   1970   
                                    crate::operation_shape::GreetingWithErrors,
 1970   1971   
                                    ModelPl::Output
 1971   1972   
                                >
 1972   1973   
                            >::Output
 1973   1974   
                        >,
 1974   1975   
 1975         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 1976         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        1976  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        1977  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 1977   1978   
 1978   1979   
                    {
 1979   1980   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 1980   1981   
        use ::aws_smithy_http_server::plugin::Plugin;
 1981   1982   
        let svc = crate::operation_shape::GreetingWithErrors::from_handler(handler);
 1982   1983   
        let svc = self.model_plugin.apply(svc);
 1983   1984   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 1984   1985   
            .apply(svc);
 1985   1986   
        let svc = self.http_plugin.apply(svc);
 1986   1987   
        self.greeting_with_errors_custom(svc)
@@ -2012,2013 +2092,2093 @@
 2032   2033   
                            <
 2033   2034   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2034   2035   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2035   2036   
                                    RestJson<L>,
 2036   2037   
                                    crate::operation_shape::GreetingWithErrors,
 2037   2038   
                                    ModelPl::Output
 2038   2039   
                                >
 2039   2040   
                            >::Output
 2040   2041   
                        >,
 2041   2042   
 2042         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2043         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2043  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2044  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2044   2045   
 2045   2046   
                    {
 2046   2047   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2047   2048   
        use ::aws_smithy_http_server::plugin::Plugin;
 2048   2049   
        let svc = crate::operation_shape::GreetingWithErrors::from_service(service);
 2049   2050   
        let svc = self.model_plugin.apply(svc);
 2050   2051   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2051   2052   
            .apply(svc);
 2052   2053   
        let svc = self.http_plugin.apply(svc);
 2053   2054   
        self.greeting_with_errors_custom(svc)
 2054   2055   
    }
 2055   2056   
 2056   2057   
    /// Sets the [`GreetingWithErrors`](crate::operation_shape::GreetingWithErrors) to a custom [`Service`](tower::Service).
 2057   2058   
    /// not constrained by the Smithy contract.
 2058   2059   
    fn greeting_with_errors_custom<S>(mut self, svc: S) -> Self
 2059   2060   
    where
 2060   2061   
        S: ::tower::Service<
 2061         -
                ::http::Request<Body>,
 2062         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2062  +
                ::http_1x::Request<Body>,
        2063  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2063   2064   
                Error = ::std::convert::Infallible,
 2064   2065   
            > + Clone
 2065   2066   
            + Send
 2066   2067   
            + 'static,
 2067   2068   
        S::Future: Send + 'static,
 2068   2069   
    {
 2069   2070   
        self.greeting_with_errors = Some(::aws_smithy_http_server::routing::Route::new(svc));
 2070   2071   
        self
 2071   2072   
    }
 2072   2073
@@ -2095,2096 +2156,2157 @@
 2115   2116   
                            <
 2116   2117   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2117   2118   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2118   2119   
                                    RestJson<L>,
 2119   2120   
                                    crate::operation_shape::HostWithPathOperation,
 2120   2121   
                                    ModelPl::Output
 2121   2122   
                                >
 2122   2123   
                            >::Output
 2123   2124   
                        >,
 2124   2125   
 2125         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2126         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2126  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2127  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2127   2128   
 2128   2129   
                    {
 2129   2130   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2130   2131   
        use ::aws_smithy_http_server::plugin::Plugin;
 2131   2132   
        let svc = crate::operation_shape::HostWithPathOperation::from_handler(handler);
 2132   2133   
        let svc = self.model_plugin.apply(svc);
 2133   2134   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2134   2135   
            .apply(svc);
 2135   2136   
        let svc = self.http_plugin.apply(svc);
 2136   2137   
        self.host_with_path_operation_custom(svc)
@@ -2162,2163 +2242,2243 @@
 2182   2183   
                            <
 2183   2184   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2184   2185   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2185   2186   
                                    RestJson<L>,
 2186   2187   
                                    crate::operation_shape::HostWithPathOperation,
 2187   2188   
                                    ModelPl::Output
 2188   2189   
                                >
 2189   2190   
                            >::Output
 2190   2191   
                        >,
 2191   2192   
 2192         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2193         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2193  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2194  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2194   2195   
 2195   2196   
                    {
 2196   2197   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2197   2198   
        use ::aws_smithy_http_server::plugin::Plugin;
 2198   2199   
        let svc = crate::operation_shape::HostWithPathOperation::from_service(service);
 2199   2200   
        let svc = self.model_plugin.apply(svc);
 2200   2201   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2201   2202   
            .apply(svc);
 2202   2203   
        let svc = self.http_plugin.apply(svc);
 2203   2204   
        self.host_with_path_operation_custom(svc)
 2204   2205   
    }
 2205   2206   
 2206   2207   
    /// Sets the [`HostWithPathOperation`](crate::operation_shape::HostWithPathOperation) to a custom [`Service`](tower::Service).
 2207   2208   
    /// not constrained by the Smithy contract.
 2208   2209   
    fn host_with_path_operation_custom<S>(mut self, svc: S) -> Self
 2209   2210   
    where
 2210   2211   
        S: ::tower::Service<
 2211         -
                ::http::Request<Body>,
 2212         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2212  +
                ::http_1x::Request<Body>,
        2213  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2213   2214   
                Error = ::std::convert::Infallible,
 2214   2215   
            > + Clone
 2215   2216   
            + Send
 2216   2217   
            + 'static,
 2217   2218   
        S::Future: Send + 'static,
 2218   2219   
    {
 2219   2220   
        self.host_with_path_operation = Some(::aws_smithy_http_server::routing::Route::new(svc));
 2220   2221   
        self
 2221   2222   
    }
 2222   2223
@@ -2245,2246 +2306,2307 @@
 2265   2266   
                            <
 2266   2267   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2267   2268   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2268   2269   
                                    RestJson<L>,
 2269   2270   
                                    crate::operation_shape::HttpChecksumRequired,
 2270   2271   
                                    ModelPl::Output
 2271   2272   
                                >
 2272   2273   
                            >::Output
 2273   2274   
                        >,
 2274   2275   
 2275         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2276         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2276  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2277  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2277   2278   
 2278   2279   
                    {
 2279   2280   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2280   2281   
        use ::aws_smithy_http_server::plugin::Plugin;
 2281   2282   
        let svc = crate::operation_shape::HttpChecksumRequired::from_handler(handler);
 2282   2283   
        let svc = self.model_plugin.apply(svc);
 2283   2284   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2284   2285   
            .apply(svc);
 2285   2286   
        let svc = self.http_plugin.apply(svc);
 2286   2287   
        self.http_checksum_required_custom(svc)
@@ -2312,2313 +2392,2393 @@
 2332   2333   
                            <
 2333   2334   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2334   2335   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2335   2336   
                                    RestJson<L>,
 2336   2337   
                                    crate::operation_shape::HttpChecksumRequired,
 2337   2338   
                                    ModelPl::Output
 2338   2339   
                                >
 2339   2340   
                            >::Output
 2340   2341   
                        >,
 2341   2342   
 2342         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2343         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2343  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2344  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2344   2345   
 2345   2346   
                    {
 2346   2347   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2347   2348   
        use ::aws_smithy_http_server::plugin::Plugin;
 2348   2349   
        let svc = crate::operation_shape::HttpChecksumRequired::from_service(service);
 2349   2350   
        let svc = self.model_plugin.apply(svc);
 2350   2351   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2351   2352   
            .apply(svc);
 2352   2353   
        let svc = self.http_plugin.apply(svc);
 2353   2354   
        self.http_checksum_required_custom(svc)
 2354   2355   
    }
 2355   2356   
 2356   2357   
    /// Sets the [`HttpChecksumRequired`](crate::operation_shape::HttpChecksumRequired) to a custom [`Service`](tower::Service).
 2357   2358   
    /// not constrained by the Smithy contract.
 2358   2359   
    fn http_checksum_required_custom<S>(mut self, svc: S) -> Self
 2359   2360   
    where
 2360   2361   
        S: ::tower::Service<
 2361         -
                ::http::Request<Body>,
 2362         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2362  +
                ::http_1x::Request<Body>,
        2363  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2363   2364   
                Error = ::std::convert::Infallible,
 2364   2365   
            > + Clone
 2365   2366   
            + Send
 2366   2367   
            + 'static,
 2367   2368   
        S::Future: Send + 'static,
 2368   2369   
    {
 2369   2370   
        self.http_checksum_required = Some(::aws_smithy_http_server::routing::Route::new(svc));
 2370   2371   
        self
 2371   2372   
    }
 2372   2373
@@ -2395,2396 +2456,2457 @@
 2415   2416   
                            <
 2416   2417   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2417   2418   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2418   2419   
                                    RestJson<L>,
 2419   2420   
                                    crate::operation_shape::HttpEmptyPrefixHeaders,
 2420   2421   
                                    ModelPl::Output
 2421   2422   
                                >
 2422   2423   
                            >::Output
 2423   2424   
                        >,
 2424   2425   
 2425         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2426         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2426  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2427  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2427   2428   
 2428   2429   
                    {
 2429   2430   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2430   2431   
        use ::aws_smithy_http_server::plugin::Plugin;
 2431   2432   
        let svc = crate::operation_shape::HttpEmptyPrefixHeaders::from_handler(handler);
 2432   2433   
        let svc = self.model_plugin.apply(svc);
 2433   2434   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2434   2435   
            .apply(svc);
 2435   2436   
        let svc = self.http_plugin.apply(svc);
 2436   2437   
        self.http_empty_prefix_headers_custom(svc)
@@ -2462,2463 +2542,2543 @@
 2482   2483   
                            <
 2483   2484   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2484   2485   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2485   2486   
                                    RestJson<L>,
 2486   2487   
                                    crate::operation_shape::HttpEmptyPrefixHeaders,
 2487   2488   
                                    ModelPl::Output
 2488   2489   
                                >
 2489   2490   
                            >::Output
 2490   2491   
                        >,
 2491   2492   
 2492         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2493         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2493  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2494  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2494   2495   
 2495   2496   
                    {
 2496   2497   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2497   2498   
        use ::aws_smithy_http_server::plugin::Plugin;
 2498   2499   
        let svc = crate::operation_shape::HttpEmptyPrefixHeaders::from_service(service);
 2499   2500   
        let svc = self.model_plugin.apply(svc);
 2500   2501   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2501   2502   
            .apply(svc);
 2502   2503   
        let svc = self.http_plugin.apply(svc);
 2503   2504   
        self.http_empty_prefix_headers_custom(svc)
 2504   2505   
    }
 2505   2506   
 2506   2507   
    /// Sets the [`HttpEmptyPrefixHeaders`](crate::operation_shape::HttpEmptyPrefixHeaders) to a custom [`Service`](tower::Service).
 2507   2508   
    /// not constrained by the Smithy contract.
 2508   2509   
    fn http_empty_prefix_headers_custom<S>(mut self, svc: S) -> Self
 2509   2510   
    where
 2510   2511   
        S: ::tower::Service<
 2511         -
                ::http::Request<Body>,
 2512         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2512  +
                ::http_1x::Request<Body>,
        2513  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2513   2514   
                Error = ::std::convert::Infallible,
 2514   2515   
            > + Clone
 2515   2516   
            + Send
 2516   2517   
            + 'static,
 2517   2518   
        S::Future: Send + 'static,
 2518   2519   
    {
 2519   2520   
        self.http_empty_prefix_headers = Some(::aws_smithy_http_server::routing::Route::new(svc));
 2520   2521   
        self
 2521   2522   
    }
 2522   2523
@@ -2545,2546 +2606,2607 @@
 2565   2566   
                            <
 2566   2567   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2567   2568   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2568   2569   
                                    RestJson<L>,
 2569   2570   
                                    crate::operation_shape::HttpEnumPayload,
 2570   2571   
                                    ModelPl::Output
 2571   2572   
                                >
 2572   2573   
                            >::Output
 2573   2574   
                        >,
 2574   2575   
 2575         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2576         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2576  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2577  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2577   2578   
 2578   2579   
                    {
 2579   2580   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2580   2581   
        use ::aws_smithy_http_server::plugin::Plugin;
 2581   2582   
        let svc = crate::operation_shape::HttpEnumPayload::from_handler(handler);
 2582   2583   
        let svc = self.model_plugin.apply(svc);
 2583   2584   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2584   2585   
            .apply(svc);
 2585   2586   
        let svc = self.http_plugin.apply(svc);
 2586   2587   
        self.http_enum_payload_custom(svc)
@@ -2612,2613 +2692,2693 @@
 2632   2633   
                            <
 2633   2634   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2634   2635   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2635   2636   
                                    RestJson<L>,
 2636   2637   
                                    crate::operation_shape::HttpEnumPayload,
 2637   2638   
                                    ModelPl::Output
 2638   2639   
                                >
 2639   2640   
                            >::Output
 2640   2641   
                        >,
 2641   2642   
 2642         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2643         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2643  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2644  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2644   2645   
 2645   2646   
                    {
 2646   2647   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2647   2648   
        use ::aws_smithy_http_server::plugin::Plugin;
 2648   2649   
        let svc = crate::operation_shape::HttpEnumPayload::from_service(service);
 2649   2650   
        let svc = self.model_plugin.apply(svc);
 2650   2651   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2651   2652   
            .apply(svc);
 2652   2653   
        let svc = self.http_plugin.apply(svc);
 2653   2654   
        self.http_enum_payload_custom(svc)
 2654   2655   
    }
 2655   2656   
 2656   2657   
    /// Sets the [`HttpEnumPayload`](crate::operation_shape::HttpEnumPayload) to a custom [`Service`](tower::Service).
 2657   2658   
    /// not constrained by the Smithy contract.
 2658   2659   
    fn http_enum_payload_custom<S>(mut self, svc: S) -> Self
 2659   2660   
    where
 2660   2661   
        S: ::tower::Service<
 2661         -
                ::http::Request<Body>,
 2662         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2662  +
                ::http_1x::Request<Body>,
        2663  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2663   2664   
                Error = ::std::convert::Infallible,
 2664   2665   
            > + Clone
 2665   2666   
            + Send
 2666   2667   
            + 'static,
 2667   2668   
        S::Future: Send + 'static,
 2668   2669   
    {
 2669   2670   
        self.http_enum_payload = Some(::aws_smithy_http_server::routing::Route::new(svc));
 2670   2671   
        self
 2671   2672   
    }
 2672   2673
@@ -2695,2696 +2756,2757 @@
 2715   2716   
                            <
 2716   2717   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2717   2718   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2718   2719   
                                    RestJson<L>,
 2719   2720   
                                    crate::operation_shape::HttpPayloadTraits,
 2720   2721   
                                    ModelPl::Output
 2721   2722   
                                >
 2722   2723   
                            >::Output
 2723   2724   
                        >,
 2724   2725   
 2725         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2726         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2726  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2727  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2727   2728   
 2728   2729   
                    {
 2729   2730   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2730   2731   
        use ::aws_smithy_http_server::plugin::Plugin;
 2731   2732   
        let svc = crate::operation_shape::HttpPayloadTraits::from_handler(handler);
 2732   2733   
        let svc = self.model_plugin.apply(svc);
 2733   2734   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2734   2735   
            .apply(svc);
 2735   2736   
        let svc = self.http_plugin.apply(svc);
 2736   2737   
        self.http_payload_traits_custom(svc)
@@ -2762,2763 +2842,2843 @@
 2782   2783   
                            <
 2783   2784   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2784   2785   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2785   2786   
                                    RestJson<L>,
 2786   2787   
                                    crate::operation_shape::HttpPayloadTraits,
 2787   2788   
                                    ModelPl::Output
 2788   2789   
                                >
 2789   2790   
                            >::Output
 2790   2791   
                        >,
 2791   2792   
 2792         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2793         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2793  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2794  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2794   2795   
 2795   2796   
                    {
 2796   2797   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2797   2798   
        use ::aws_smithy_http_server::plugin::Plugin;
 2798   2799   
        let svc = crate::operation_shape::HttpPayloadTraits::from_service(service);
 2799   2800   
        let svc = self.model_plugin.apply(svc);
 2800   2801   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2801   2802   
            .apply(svc);
 2802   2803   
        let svc = self.http_plugin.apply(svc);
 2803   2804   
        self.http_payload_traits_custom(svc)
 2804   2805   
    }
 2805   2806   
 2806   2807   
    /// Sets the [`HttpPayloadTraits`](crate::operation_shape::HttpPayloadTraits) to a custom [`Service`](tower::Service).
 2807   2808   
    /// not constrained by the Smithy contract.
 2808   2809   
    fn http_payload_traits_custom<S>(mut self, svc: S) -> Self
 2809   2810   
    where
 2810   2811   
        S: ::tower::Service<
 2811         -
                ::http::Request<Body>,
 2812         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2812  +
                ::http_1x::Request<Body>,
        2813  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2813   2814   
                Error = ::std::convert::Infallible,
 2814   2815   
            > + Clone
 2815   2816   
            + Send
 2816   2817   
            + 'static,
 2817   2818   
        S::Future: Send + 'static,
 2818   2819   
    {
 2819   2820   
        self.http_payload_traits = Some(::aws_smithy_http_server::routing::Route::new(svc));
 2820   2821   
        self
 2821   2822   
    }
 2822   2823
@@ -2845,2846 +2906,2907 @@
 2865   2866   
                            <
 2866   2867   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2867   2868   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2868   2869   
                                    RestJson<L>,
 2869   2870   
                                    crate::operation_shape::HttpPayloadTraitsWithMediaType,
 2870   2871   
                                    ModelPl::Output
 2871   2872   
                                >
 2872   2873   
                            >::Output
 2873   2874   
                        >,
 2874   2875   
 2875         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2876         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2876  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2877  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2877   2878   
 2878   2879   
                    {
 2879   2880   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2880   2881   
        use ::aws_smithy_http_server::plugin::Plugin;
 2881   2882   
        let svc = crate::operation_shape::HttpPayloadTraitsWithMediaType::from_handler(handler);
 2882   2883   
        let svc = self.model_plugin.apply(svc);
 2883   2884   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2884   2885   
            .apply(svc);
 2885   2886   
        let svc = self.http_plugin.apply(svc);
 2886   2887   
        self.http_payload_traits_with_media_type_custom(svc)
@@ -2912,2913 +2992,2993 @@
 2932   2933   
                            <
 2933   2934   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 2934   2935   
                                as ::aws_smithy_http_server::plugin::Plugin<
 2935   2936   
                                    RestJson<L>,
 2936   2937   
                                    crate::operation_shape::HttpPayloadTraitsWithMediaType,
 2937   2938   
                                    ModelPl::Output
 2938   2939   
                                >
 2939   2940   
                            >::Output
 2940   2941   
                        >,
 2941   2942   
 2942         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 2943         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        2943  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        2944  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 2944   2945   
 2945   2946   
                    {
 2946   2947   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 2947   2948   
        use ::aws_smithy_http_server::plugin::Plugin;
 2948   2949   
        let svc = crate::operation_shape::HttpPayloadTraitsWithMediaType::from_service(service);
 2949   2950   
        let svc = self.model_plugin.apply(svc);
 2950   2951   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 2951   2952   
            .apply(svc);
 2952   2953   
        let svc = self.http_plugin.apply(svc);
 2953   2954   
        self.http_payload_traits_with_media_type_custom(svc)
 2954   2955   
    }
 2955   2956   
 2956   2957   
    /// Sets the [`HttpPayloadTraitsWithMediaType`](crate::operation_shape::HttpPayloadTraitsWithMediaType) to a custom [`Service`](tower::Service).
 2957   2958   
    /// not constrained by the Smithy contract.
 2958   2959   
    fn http_payload_traits_with_media_type_custom<S>(mut self, svc: S) -> Self
 2959   2960   
    where
 2960   2961   
        S: ::tower::Service<
 2961         -
                ::http::Request<Body>,
 2962         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        2962  +
                ::http_1x::Request<Body>,
        2963  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 2963   2964   
                Error = ::std::convert::Infallible,
 2964   2965   
            > + Clone
 2965   2966   
            + Send
 2966   2967   
            + 'static,
 2967   2968   
        S::Future: Send + 'static,
 2968   2969   
    {
 2969   2970   
        self.http_payload_traits_with_media_type =
 2970   2971   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 2971   2972   
        self
 2972   2973   
    }
@@ -2996,2997 +3057,3058 @@
 3016   3017   
                            <
 3017   3018   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3018   3019   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3019   3020   
                                    RestJson<L>,
 3020   3021   
                                    crate::operation_shape::HttpPayloadWithStructure,
 3021   3022   
                                    ModelPl::Output
 3022   3023   
                                >
 3023   3024   
                            >::Output
 3024   3025   
                        >,
 3025   3026   
 3026         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3027         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3027  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3028  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3028   3029   
 3029   3030   
                    {
 3030   3031   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3031   3032   
        use ::aws_smithy_http_server::plugin::Plugin;
 3032   3033   
        let svc = crate::operation_shape::HttpPayloadWithStructure::from_handler(handler);
 3033   3034   
        let svc = self.model_plugin.apply(svc);
 3034   3035   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3035   3036   
            .apply(svc);
 3036   3037   
        let svc = self.http_plugin.apply(svc);
 3037   3038   
        self.http_payload_with_structure_custom(svc)
@@ -3063,3064 +3143,3144 @@
 3083   3084   
                            <
 3084   3085   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3085   3086   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3086   3087   
                                    RestJson<L>,
 3087   3088   
                                    crate::operation_shape::HttpPayloadWithStructure,
 3088   3089   
                                    ModelPl::Output
 3089   3090   
                                >
 3090   3091   
                            >::Output
 3091   3092   
                        >,
 3092   3093   
 3093         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3094         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3094  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3095  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3095   3096   
 3096   3097   
                    {
 3097   3098   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3098   3099   
        use ::aws_smithy_http_server::plugin::Plugin;
 3099   3100   
        let svc = crate::operation_shape::HttpPayloadWithStructure::from_service(service);
 3100   3101   
        let svc = self.model_plugin.apply(svc);
 3101   3102   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3102   3103   
            .apply(svc);
 3103   3104   
        let svc = self.http_plugin.apply(svc);
 3104   3105   
        self.http_payload_with_structure_custom(svc)
 3105   3106   
    }
 3106   3107   
 3107   3108   
    /// Sets the [`HttpPayloadWithStructure`](crate::operation_shape::HttpPayloadWithStructure) to a custom [`Service`](tower::Service).
 3108   3109   
    /// not constrained by the Smithy contract.
 3109   3110   
    fn http_payload_with_structure_custom<S>(mut self, svc: S) -> Self
 3110   3111   
    where
 3111   3112   
        S: ::tower::Service<
 3112         -
                ::http::Request<Body>,
 3113         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        3113  +
                ::http_1x::Request<Body>,
        3114  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 3114   3115   
                Error = ::std::convert::Infallible,
 3115   3116   
            > + Clone
 3116   3117   
            + Send
 3117   3118   
            + 'static,
 3118   3119   
        S::Future: Send + 'static,
 3119   3120   
    {
 3120   3121   
        self.http_payload_with_structure = Some(::aws_smithy_http_server::routing::Route::new(svc));
 3121   3122   
        self
 3122   3123   
    }
 3123   3124
@@ -3146,3147 +3207,3208 @@
 3166   3167   
                            <
 3167   3168   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3168   3169   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3169   3170   
                                    RestJson<L>,
 3170   3171   
                                    crate::operation_shape::HttpPayloadWithUnion,
 3171   3172   
                                    ModelPl::Output
 3172   3173   
                                >
 3173   3174   
                            >::Output
 3174   3175   
                        >,
 3175   3176   
 3176         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3177         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3177  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3178  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3178   3179   
 3179   3180   
                    {
 3180   3181   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3181   3182   
        use ::aws_smithy_http_server::plugin::Plugin;
 3182   3183   
        let svc = crate::operation_shape::HttpPayloadWithUnion::from_handler(handler);
 3183   3184   
        let svc = self.model_plugin.apply(svc);
 3184   3185   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3185   3186   
            .apply(svc);
 3186   3187   
        let svc = self.http_plugin.apply(svc);
 3187   3188   
        self.http_payload_with_union_custom(svc)
@@ -3213,3214 +3293,3294 @@
 3233   3234   
                            <
 3234   3235   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3235   3236   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3236   3237   
                                    RestJson<L>,
 3237   3238   
                                    crate::operation_shape::HttpPayloadWithUnion,
 3238   3239   
                                    ModelPl::Output
 3239   3240   
                                >
 3240   3241   
                            >::Output
 3241   3242   
                        >,
 3242   3243   
 3243         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3244         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3244  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3245  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3245   3246   
 3246   3247   
                    {
 3247   3248   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3248   3249   
        use ::aws_smithy_http_server::plugin::Plugin;
 3249   3250   
        let svc = crate::operation_shape::HttpPayloadWithUnion::from_service(service);
 3250   3251   
        let svc = self.model_plugin.apply(svc);
 3251   3252   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3252   3253   
            .apply(svc);
 3253   3254   
        let svc = self.http_plugin.apply(svc);
 3254   3255   
        self.http_payload_with_union_custom(svc)
 3255   3256   
    }
 3256   3257   
 3257   3258   
    /// Sets the [`HttpPayloadWithUnion`](crate::operation_shape::HttpPayloadWithUnion) to a custom [`Service`](tower::Service).
 3258   3259   
    /// not constrained by the Smithy contract.
 3259   3260   
    fn http_payload_with_union_custom<S>(mut self, svc: S) -> Self
 3260   3261   
    where
 3261   3262   
        S: ::tower::Service<
 3262         -
                ::http::Request<Body>,
 3263         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        3263  +
                ::http_1x::Request<Body>,
        3264  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 3264   3265   
                Error = ::std::convert::Infallible,
 3265   3266   
            > + Clone
 3266   3267   
            + Send
 3267   3268   
            + 'static,
 3268   3269   
        S::Future: Send + 'static,
 3269   3270   
    {
 3270   3271   
        self.http_payload_with_union = Some(::aws_smithy_http_server::routing::Route::new(svc));
 3271   3272   
        self
 3272   3273   
    }
 3273   3274
@@ -3296,3297 +3357,3358 @@
 3316   3317   
                            <
 3317   3318   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3318   3319   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3319   3320   
                                    RestJson<L>,
 3320   3321   
                                    crate::operation_shape::HttpPrefixHeaders,
 3321   3322   
                                    ModelPl::Output
 3322   3323   
                                >
 3323   3324   
                            >::Output
 3324   3325   
                        >,
 3325   3326   
 3326         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3327         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3327  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3328  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3328   3329   
 3329   3330   
                    {
 3330   3331   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3331   3332   
        use ::aws_smithy_http_server::plugin::Plugin;
 3332   3333   
        let svc = crate::operation_shape::HttpPrefixHeaders::from_handler(handler);
 3333   3334   
        let svc = self.model_plugin.apply(svc);
 3334   3335   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3335   3336   
            .apply(svc);
 3336   3337   
        let svc = self.http_plugin.apply(svc);
 3337   3338   
        self.http_prefix_headers_custom(svc)
@@ -3363,3364 +3443,3444 @@
 3383   3384   
                            <
 3384   3385   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3385   3386   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3386   3387   
                                    RestJson<L>,
 3387   3388   
                                    crate::operation_shape::HttpPrefixHeaders,
 3388   3389   
                                    ModelPl::Output
 3389   3390   
                                >
 3390   3391   
                            >::Output
 3391   3392   
                        >,
 3392   3393   
 3393         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3394         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3394  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3395  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3395   3396   
 3396   3397   
                    {
 3397   3398   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3398   3399   
        use ::aws_smithy_http_server::plugin::Plugin;
 3399   3400   
        let svc = crate::operation_shape::HttpPrefixHeaders::from_service(service);
 3400   3401   
        let svc = self.model_plugin.apply(svc);
 3401   3402   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3402   3403   
            .apply(svc);
 3403   3404   
        let svc = self.http_plugin.apply(svc);
 3404   3405   
        self.http_prefix_headers_custom(svc)
 3405   3406   
    }
 3406   3407   
 3407   3408   
    /// Sets the [`HttpPrefixHeaders`](crate::operation_shape::HttpPrefixHeaders) to a custom [`Service`](tower::Service).
 3408   3409   
    /// not constrained by the Smithy contract.
 3409   3410   
    fn http_prefix_headers_custom<S>(mut self, svc: S) -> Self
 3410   3411   
    where
 3411   3412   
        S: ::tower::Service<
 3412         -
                ::http::Request<Body>,
 3413         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        3413  +
                ::http_1x::Request<Body>,
        3414  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 3414   3415   
                Error = ::std::convert::Infallible,
 3415   3416   
            > + Clone
 3416   3417   
            + Send
 3417   3418   
            + 'static,
 3418   3419   
        S::Future: Send + 'static,
 3419   3420   
    {
 3420   3421   
        self.http_prefix_headers = Some(::aws_smithy_http_server::routing::Route::new(svc));
 3421   3422   
        self
 3422   3423   
    }
 3423   3424
@@ -3446,3447 +3507,3508 @@
 3466   3467   
                            <
 3467   3468   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3468   3469   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3469   3470   
                                    RestJson<L>,
 3470   3471   
                                    crate::operation_shape::HttpPrefixHeadersInResponse,
 3471   3472   
                                    ModelPl::Output
 3472   3473   
                                >
 3473   3474   
                            >::Output
 3474   3475   
                        >,
 3475   3476   
 3476         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3477         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3477  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3478  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3478   3479   
 3479   3480   
                    {
 3480   3481   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3481   3482   
        use ::aws_smithy_http_server::plugin::Plugin;
 3482   3483   
        let svc = crate::operation_shape::HttpPrefixHeadersInResponse::from_handler(handler);
 3483   3484   
        let svc = self.model_plugin.apply(svc);
 3484   3485   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3485   3486   
            .apply(svc);
 3486   3487   
        let svc = self.http_plugin.apply(svc);
 3487   3488   
        self.http_prefix_headers_in_response_custom(svc)
@@ -3513,3514 +3593,3594 @@
 3533   3534   
                            <
 3534   3535   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3535   3536   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3536   3537   
                                    RestJson<L>,
 3537   3538   
                                    crate::operation_shape::HttpPrefixHeadersInResponse,
 3538   3539   
                                    ModelPl::Output
 3539   3540   
                                >
 3540   3541   
                            >::Output
 3541   3542   
                        >,
 3542   3543   
 3543         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3544         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3544  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3545  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3545   3546   
 3546   3547   
                    {
 3547   3548   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3548   3549   
        use ::aws_smithy_http_server::plugin::Plugin;
 3549   3550   
        let svc = crate::operation_shape::HttpPrefixHeadersInResponse::from_service(service);
 3550   3551   
        let svc = self.model_plugin.apply(svc);
 3551   3552   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3552   3553   
            .apply(svc);
 3553   3554   
        let svc = self.http_plugin.apply(svc);
 3554   3555   
        self.http_prefix_headers_in_response_custom(svc)
 3555   3556   
    }
 3556   3557   
 3557   3558   
    /// Sets the [`HttpPrefixHeadersInResponse`](crate::operation_shape::HttpPrefixHeadersInResponse) to a custom [`Service`](tower::Service).
 3558   3559   
    /// not constrained by the Smithy contract.
 3559   3560   
    fn http_prefix_headers_in_response_custom<S>(mut self, svc: S) -> Self
 3560   3561   
    where
 3561   3562   
        S: ::tower::Service<
 3562         -
                ::http::Request<Body>,
 3563         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        3563  +
                ::http_1x::Request<Body>,
        3564  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 3564   3565   
                Error = ::std::convert::Infallible,
 3565   3566   
            > + Clone
 3566   3567   
            + Send
 3567   3568   
            + 'static,
 3568   3569   
        S::Future: Send + 'static,
 3569   3570   
    {
 3570   3571   
        self.http_prefix_headers_in_response =
 3571   3572   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 3572   3573   
        self
 3573   3574   
    }
@@ -3597,3598 +3658,3659 @@
 3617   3618   
                            <
 3618   3619   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3619   3620   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3620   3621   
                                    RestJson<L>,
 3621   3622   
                                    crate::operation_shape::HttpRequestWithFloatLabels,
 3622   3623   
                                    ModelPl::Output
 3623   3624   
                                >
 3624   3625   
                            >::Output
 3625   3626   
                        >,
 3626   3627   
 3627         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3628         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3628  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3629  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3629   3630   
 3630   3631   
                    {
 3631   3632   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3632   3633   
        use ::aws_smithy_http_server::plugin::Plugin;
 3633   3634   
        let svc = crate::operation_shape::HttpRequestWithFloatLabels::from_handler(handler);
 3634   3635   
        let svc = self.model_plugin.apply(svc);
 3635   3636   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3636   3637   
            .apply(svc);
 3637   3638   
        let svc = self.http_plugin.apply(svc);
 3638   3639   
        self.http_request_with_float_labels_custom(svc)
@@ -3664,3665 +3744,3745 @@
 3684   3685   
                            <
 3685   3686   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3686   3687   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3687   3688   
                                    RestJson<L>,
 3688   3689   
                                    crate::operation_shape::HttpRequestWithFloatLabels,
 3689   3690   
                                    ModelPl::Output
 3690   3691   
                                >
 3691   3692   
                            >::Output
 3692   3693   
                        >,
 3693   3694   
 3694         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3695         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3695  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3696  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3696   3697   
 3697   3698   
                    {
 3698   3699   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3699   3700   
        use ::aws_smithy_http_server::plugin::Plugin;
 3700   3701   
        let svc = crate::operation_shape::HttpRequestWithFloatLabels::from_service(service);
 3701   3702   
        let svc = self.model_plugin.apply(svc);
 3702   3703   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3703   3704   
            .apply(svc);
 3704   3705   
        let svc = self.http_plugin.apply(svc);
 3705   3706   
        self.http_request_with_float_labels_custom(svc)
 3706   3707   
    }
 3707   3708   
 3708   3709   
    /// Sets the [`HttpRequestWithFloatLabels`](crate::operation_shape::HttpRequestWithFloatLabels) to a custom [`Service`](tower::Service).
 3709   3710   
    /// not constrained by the Smithy contract.
 3710   3711   
    fn http_request_with_float_labels_custom<S>(mut self, svc: S) -> Self
 3711   3712   
    where
 3712   3713   
        S: ::tower::Service<
 3713         -
                ::http::Request<Body>,
 3714         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        3714  +
                ::http_1x::Request<Body>,
        3715  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 3715   3716   
                Error = ::std::convert::Infallible,
 3716   3717   
            > + Clone
 3717   3718   
            + Send
 3718   3719   
            + 'static,
 3719   3720   
        S::Future: Send + 'static,
 3720   3721   
    {
 3721   3722   
        self.http_request_with_float_labels =
 3722   3723   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 3723   3724   
        self
 3724   3725   
    }
@@ -3748,3749 +3809,3810 @@
 3768   3769   
                            <
 3769   3770   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3770   3771   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3771   3772   
                                    RestJson<L>,
 3772   3773   
                                    crate::operation_shape::HttpRequestWithGreedyLabelInPath,
 3773   3774   
                                    ModelPl::Output
 3774   3775   
                                >
 3775   3776   
                            >::Output
 3776   3777   
                        >,
 3777   3778   
 3778         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3779         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3779  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3780  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3780   3781   
 3781   3782   
                    {
 3782   3783   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3783   3784   
        use ::aws_smithy_http_server::plugin::Plugin;
 3784   3785   
        let svc = crate::operation_shape::HttpRequestWithGreedyLabelInPath::from_handler(handler);
 3785   3786   
        let svc = self.model_plugin.apply(svc);
 3786   3787   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3787   3788   
            .apply(svc);
 3788   3789   
        let svc = self.http_plugin.apply(svc);
 3789   3790   
        self.http_request_with_greedy_label_in_path_custom(svc)
@@ -3815,3816 +3895,3896 @@
 3835   3836   
                            <
 3836   3837   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3837   3838   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3838   3839   
                                    RestJson<L>,
 3839   3840   
                                    crate::operation_shape::HttpRequestWithGreedyLabelInPath,
 3840   3841   
                                    ModelPl::Output
 3841   3842   
                                >
 3842   3843   
                            >::Output
 3843   3844   
                        >,
 3844   3845   
 3845         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3846         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3846  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3847  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3847   3848   
 3848   3849   
                    {
 3849   3850   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3850   3851   
        use ::aws_smithy_http_server::plugin::Plugin;
 3851   3852   
        let svc = crate::operation_shape::HttpRequestWithGreedyLabelInPath::from_service(service);
 3852   3853   
        let svc = self.model_plugin.apply(svc);
 3853   3854   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3854   3855   
            .apply(svc);
 3855   3856   
        let svc = self.http_plugin.apply(svc);
 3856   3857   
        self.http_request_with_greedy_label_in_path_custom(svc)
 3857   3858   
    }
 3858   3859   
 3859   3860   
    /// Sets the [`HttpRequestWithGreedyLabelInPath`](crate::operation_shape::HttpRequestWithGreedyLabelInPath) to a custom [`Service`](tower::Service).
 3860   3861   
    /// not constrained by the Smithy contract.
 3861   3862   
    fn http_request_with_greedy_label_in_path_custom<S>(mut self, svc: S) -> Self
 3862   3863   
    where
 3863   3864   
        S: ::tower::Service<
 3864         -
                ::http::Request<Body>,
 3865         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        3865  +
                ::http_1x::Request<Body>,
        3866  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 3866   3867   
                Error = ::std::convert::Infallible,
 3867   3868   
            > + Clone
 3868   3869   
            + Send
 3869   3870   
            + 'static,
 3870   3871   
        S::Future: Send + 'static,
 3871   3872   
    {
 3872   3873   
        self.http_request_with_greedy_label_in_path =
 3873   3874   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 3874   3875   
        self
 3875   3876   
    }
@@ -3899,3900 +3960,3961 @@
 3919   3920   
                            <
 3920   3921   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3921   3922   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3922   3923   
                                    RestJson<L>,
 3923   3924   
                                    crate::operation_shape::HttpRequestWithLabels,
 3924   3925   
                                    ModelPl::Output
 3925   3926   
                                >
 3926   3927   
                            >::Output
 3927   3928   
                        >,
 3928   3929   
 3929         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3930         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3930  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3931  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3931   3932   
 3932   3933   
                    {
 3933   3934   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 3934   3935   
        use ::aws_smithy_http_server::plugin::Plugin;
 3935   3936   
        let svc = crate::operation_shape::HttpRequestWithLabels::from_handler(handler);
 3936   3937   
        let svc = self.model_plugin.apply(svc);
 3937   3938   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 3938   3939   
            .apply(svc);
 3939   3940   
        let svc = self.http_plugin.apply(svc);
 3940   3941   
        self.http_request_with_labels_custom(svc)
@@ -3966,3967 +4046,4047 @@
 3986   3987   
                            <
 3987   3988   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 3988   3989   
                                as ::aws_smithy_http_server::plugin::Plugin<
 3989   3990   
                                    RestJson<L>,
 3990   3991   
                                    crate::operation_shape::HttpRequestWithLabels,
 3991   3992   
                                    ModelPl::Output
 3992   3993   
                                >
 3993   3994   
                            >::Output
 3994   3995   
                        >,
 3995   3996   
 3996         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 3997         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        3997  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        3998  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 3998   3999   
 3999   4000   
                    {
 4000   4001   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4001   4002   
        use ::aws_smithy_http_server::plugin::Plugin;
 4002   4003   
        let svc = crate::operation_shape::HttpRequestWithLabels::from_service(service);
 4003   4004   
        let svc = self.model_plugin.apply(svc);
 4004   4005   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4005   4006   
            .apply(svc);
 4006   4007   
        let svc = self.http_plugin.apply(svc);
 4007   4008   
        self.http_request_with_labels_custom(svc)
 4008   4009   
    }
 4009   4010   
 4010   4011   
    /// Sets the [`HttpRequestWithLabels`](crate::operation_shape::HttpRequestWithLabels) to a custom [`Service`](tower::Service).
 4011   4012   
    /// not constrained by the Smithy contract.
 4012   4013   
    fn http_request_with_labels_custom<S>(mut self, svc: S) -> Self
 4013   4014   
    where
 4014   4015   
        S: ::tower::Service<
 4015         -
                ::http::Request<Body>,
 4016         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4016  +
                ::http_1x::Request<Body>,
        4017  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4017   4018   
                Error = ::std::convert::Infallible,
 4018   4019   
            > + Clone
 4019   4020   
            + Send
 4020   4021   
            + 'static,
 4021   4022   
        S::Future: Send + 'static,
 4022   4023   
    {
 4023   4024   
        self.http_request_with_labels = Some(::aws_smithy_http_server::routing::Route::new(svc));
 4024   4025   
        self
 4025   4026   
    }
 4026   4027
@@ -4049,4050 +4110,4111 @@
 4069   4070   
                            <
 4070   4071   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4071   4072   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4072   4073   
                                    RestJson<L>,
 4073   4074   
                                    crate::operation_shape::HttpRequestWithLabelsAndTimestampFormat,
 4074   4075   
                                    ModelPl::Output
 4075   4076   
                                >
 4076   4077   
                            >::Output
 4077   4078   
                        >,
 4078   4079   
 4079         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4080         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4080  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4081  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4081   4082   
 4082   4083   
                    {
 4083   4084   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4084   4085   
        use ::aws_smithy_http_server::plugin::Plugin;
 4085   4086   
        let svc =
 4086   4087   
            crate::operation_shape::HttpRequestWithLabelsAndTimestampFormat::from_handler(handler);
 4087   4088   
        let svc = self.model_plugin.apply(svc);
 4088   4089   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4089   4090   
            .apply(svc);
 4090   4091   
        let svc = self.http_plugin.apply(svc);
@@ -4117,4118 +4198,4199 @@
 4137   4138   
                            <
 4138   4139   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4139   4140   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4140   4141   
                                    RestJson<L>,
 4141   4142   
                                    crate::operation_shape::HttpRequestWithLabelsAndTimestampFormat,
 4142   4143   
                                    ModelPl::Output
 4143   4144   
                                >
 4144   4145   
                            >::Output
 4145   4146   
                        >,
 4146   4147   
 4147         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4148         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4148  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4149  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4149   4150   
 4150   4151   
                    {
 4151   4152   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4152   4153   
        use ::aws_smithy_http_server::plugin::Plugin;
 4153   4154   
        let svc =
 4154   4155   
            crate::operation_shape::HttpRequestWithLabelsAndTimestampFormat::from_service(service);
 4155   4156   
        let svc = self.model_plugin.apply(svc);
 4156   4157   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4157   4158   
            .apply(svc);
 4158   4159   
        let svc = self.http_plugin.apply(svc);
 4159   4160   
        self.http_request_with_labels_and_timestamp_format_custom(svc)
 4160   4161   
    }
 4161   4162   
 4162   4163   
    /// Sets the [`HttpRequestWithLabelsAndTimestampFormat`](crate::operation_shape::HttpRequestWithLabelsAndTimestampFormat) to a custom [`Service`](tower::Service).
 4163   4164   
    /// not constrained by the Smithy contract.
 4164   4165   
    fn http_request_with_labels_and_timestamp_format_custom<S>(mut self, svc: S) -> Self
 4165   4166   
    where
 4166   4167   
        S: ::tower::Service<
 4167         -
                ::http::Request<Body>,
 4168         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4168  +
                ::http_1x::Request<Body>,
        4169  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4169   4170   
                Error = ::std::convert::Infallible,
 4170   4171   
            > + Clone
 4171   4172   
            + Send
 4172   4173   
            + 'static,
 4173   4174   
        S::Future: Send + 'static,
 4174   4175   
    {
 4175   4176   
        self.http_request_with_labels_and_timestamp_format =
 4176   4177   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 4177   4178   
        self
 4178   4179   
    }
@@ -4202,4203 +4263,4264 @@
 4222   4223   
                            <
 4223   4224   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4224   4225   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4225   4226   
                                    RestJson<L>,
 4226   4227   
                                    crate::operation_shape::HttpRequestWithRegexLiteral,
 4227   4228   
                                    ModelPl::Output
 4228   4229   
                                >
 4229   4230   
                            >::Output
 4230   4231   
                        >,
 4231   4232   
 4232         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4233         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4233  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4234  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4234   4235   
 4235   4236   
                    {
 4236   4237   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4237   4238   
        use ::aws_smithy_http_server::plugin::Plugin;
 4238   4239   
        let svc = crate::operation_shape::HttpRequestWithRegexLiteral::from_handler(handler);
 4239   4240   
        let svc = self.model_plugin.apply(svc);
 4240   4241   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4241   4242   
            .apply(svc);
 4242   4243   
        let svc = self.http_plugin.apply(svc);
 4243   4244   
        self.http_request_with_regex_literal_custom(svc)
@@ -4269,4270 +4349,4350 @@
 4289   4290   
                            <
 4290   4291   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4291   4292   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4292   4293   
                                    RestJson<L>,
 4293   4294   
                                    crate::operation_shape::HttpRequestWithRegexLiteral,
 4294   4295   
                                    ModelPl::Output
 4295   4296   
                                >
 4296   4297   
                            >::Output
 4297   4298   
                        >,
 4298   4299   
 4299         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4300         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4300  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4301  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4301   4302   
 4302   4303   
                    {
 4303   4304   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4304   4305   
        use ::aws_smithy_http_server::plugin::Plugin;
 4305   4306   
        let svc = crate::operation_shape::HttpRequestWithRegexLiteral::from_service(service);
 4306   4307   
        let svc = self.model_plugin.apply(svc);
 4307   4308   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4308   4309   
            .apply(svc);
 4309   4310   
        let svc = self.http_plugin.apply(svc);
 4310   4311   
        self.http_request_with_regex_literal_custom(svc)
 4311   4312   
    }
 4312   4313   
 4313   4314   
    /// Sets the [`HttpRequestWithRegexLiteral`](crate::operation_shape::HttpRequestWithRegexLiteral) to a custom [`Service`](tower::Service).
 4314   4315   
    /// not constrained by the Smithy contract.
 4315   4316   
    fn http_request_with_regex_literal_custom<S>(mut self, svc: S) -> Self
 4316   4317   
    where
 4317   4318   
        S: ::tower::Service<
 4318         -
                ::http::Request<Body>,
 4319         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4319  +
                ::http_1x::Request<Body>,
        4320  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4320   4321   
                Error = ::std::convert::Infallible,
 4321   4322   
            > + Clone
 4322   4323   
            + Send
 4323   4324   
            + 'static,
 4324   4325   
        S::Future: Send + 'static,
 4325   4326   
    {
 4326   4327   
        self.http_request_with_regex_literal =
 4327   4328   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 4328   4329   
        self
 4329   4330   
    }
@@ -4353,4354 +4414,4415 @@
 4373   4374   
                            <
 4374   4375   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4375   4376   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4376   4377   
                                    RestJson<L>,
 4377   4378   
                                    crate::operation_shape::HttpResponseCode,
 4378   4379   
                                    ModelPl::Output
 4379   4380   
                                >
 4380   4381   
                            >::Output
 4381   4382   
                        >,
 4382   4383   
 4383         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4384         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4384  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4385  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4385   4386   
 4386   4387   
                    {
 4387   4388   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4388   4389   
        use ::aws_smithy_http_server::plugin::Plugin;
 4389   4390   
        let svc = crate::operation_shape::HttpResponseCode::from_handler(handler);
 4390   4391   
        let svc = self.model_plugin.apply(svc);
 4391   4392   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4392   4393   
            .apply(svc);
 4393   4394   
        let svc = self.http_plugin.apply(svc);
 4394   4395   
        self.http_response_code_custom(svc)
@@ -4420,4421 +4500,4501 @@
 4440   4441   
                            <
 4441   4442   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4442   4443   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4443   4444   
                                    RestJson<L>,
 4444   4445   
                                    crate::operation_shape::HttpResponseCode,
 4445   4446   
                                    ModelPl::Output
 4446   4447   
                                >
 4447   4448   
                            >::Output
 4448   4449   
                        >,
 4449   4450   
 4450         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4451         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4451  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4452  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4452   4453   
 4453   4454   
                    {
 4454   4455   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4455   4456   
        use ::aws_smithy_http_server::plugin::Plugin;
 4456   4457   
        let svc = crate::operation_shape::HttpResponseCode::from_service(service);
 4457   4458   
        let svc = self.model_plugin.apply(svc);
 4458   4459   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4459   4460   
            .apply(svc);
 4460   4461   
        let svc = self.http_plugin.apply(svc);
 4461   4462   
        self.http_response_code_custom(svc)
 4462   4463   
    }
 4463   4464   
 4464   4465   
    /// Sets the [`HttpResponseCode`](crate::operation_shape::HttpResponseCode) to a custom [`Service`](tower::Service).
 4465   4466   
    /// not constrained by the Smithy contract.
 4466   4467   
    fn http_response_code_custom<S>(mut self, svc: S) -> Self
 4467   4468   
    where
 4468   4469   
        S: ::tower::Service<
 4469         -
                ::http::Request<Body>,
 4470         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4470  +
                ::http_1x::Request<Body>,
        4471  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4471   4472   
                Error = ::std::convert::Infallible,
 4472   4473   
            > + Clone
 4473   4474   
            + Send
 4474   4475   
            + 'static,
 4475   4476   
        S::Future: Send + 'static,
 4476   4477   
    {
 4477   4478   
        self.http_response_code = Some(::aws_smithy_http_server::routing::Route::new(svc));
 4478   4479   
        self
 4479   4480   
    }
 4480   4481
@@ -4503,4504 +4564,4565 @@
 4523   4524   
                            <
 4524   4525   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4525   4526   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4526   4527   
                                    RestJson<L>,
 4527   4528   
                                    crate::operation_shape::HttpStringPayload,
 4528   4529   
                                    ModelPl::Output
 4529   4530   
                                >
 4530   4531   
                            >::Output
 4531   4532   
                        >,
 4532   4533   
 4533         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4534         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4534  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4535  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4535   4536   
 4536   4537   
                    {
 4537   4538   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4538   4539   
        use ::aws_smithy_http_server::plugin::Plugin;
 4539   4540   
        let svc = crate::operation_shape::HttpStringPayload::from_handler(handler);
 4540   4541   
        let svc = self.model_plugin.apply(svc);
 4541   4542   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4542   4543   
            .apply(svc);
 4543   4544   
        let svc = self.http_plugin.apply(svc);
 4544   4545   
        self.http_string_payload_custom(svc)
@@ -4570,4571 +4650,4651 @@
 4590   4591   
                            <
 4591   4592   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4592   4593   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4593   4594   
                                    RestJson<L>,
 4594   4595   
                                    crate::operation_shape::HttpStringPayload,
 4595   4596   
                                    ModelPl::Output
 4596   4597   
                                >
 4597   4598   
                            >::Output
 4598   4599   
                        >,
 4599   4600   
 4600         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4601         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4601  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4602  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4602   4603   
 4603   4604   
                    {
 4604   4605   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4605   4606   
        use ::aws_smithy_http_server::plugin::Plugin;
 4606   4607   
        let svc = crate::operation_shape::HttpStringPayload::from_service(service);
 4607   4608   
        let svc = self.model_plugin.apply(svc);
 4608   4609   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4609   4610   
            .apply(svc);
 4610   4611   
        let svc = self.http_plugin.apply(svc);
 4611   4612   
        self.http_string_payload_custom(svc)
 4612   4613   
    }
 4613   4614   
 4614   4615   
    /// Sets the [`HttpStringPayload`](crate::operation_shape::HttpStringPayload) to a custom [`Service`](tower::Service).
 4615   4616   
    /// not constrained by the Smithy contract.
 4616   4617   
    fn http_string_payload_custom<S>(mut self, svc: S) -> Self
 4617   4618   
    where
 4618   4619   
        S: ::tower::Service<
 4619         -
                ::http::Request<Body>,
 4620         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4620  +
                ::http_1x::Request<Body>,
        4621  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4621   4622   
                Error = ::std::convert::Infallible,
 4622   4623   
            > + Clone
 4623   4624   
            + Send
 4624   4625   
            + 'static,
 4625   4626   
        S::Future: Send + 'static,
 4626   4627   
    {
 4627   4628   
        self.http_string_payload = Some(::aws_smithy_http_server::routing::Route::new(svc));
 4628   4629   
        self
 4629   4630   
    }
 4630   4631
@@ -4653,4654 +4714,4715 @@
 4673   4674   
                            <
 4674   4675   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4675   4676   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4676   4677   
                                    RestJson<L>,
 4677   4678   
                                    crate::operation_shape::IgnoreQueryParamsInResponse,
 4678   4679   
                                    ModelPl::Output
 4679   4680   
                                >
 4680   4681   
                            >::Output
 4681   4682   
                        >,
 4682   4683   
 4683         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4684         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4684  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4685  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4685   4686   
 4686   4687   
                    {
 4687   4688   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4688   4689   
        use ::aws_smithy_http_server::plugin::Plugin;
 4689   4690   
        let svc = crate::operation_shape::IgnoreQueryParamsInResponse::from_handler(handler);
 4690   4691   
        let svc = self.model_plugin.apply(svc);
 4691   4692   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4692   4693   
            .apply(svc);
 4693   4694   
        let svc = self.http_plugin.apply(svc);
 4694   4695   
        self.ignore_query_params_in_response_custom(svc)
@@ -4720,4721 +4800,4801 @@
 4740   4741   
                            <
 4741   4742   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4742   4743   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4743   4744   
                                    RestJson<L>,
 4744   4745   
                                    crate::operation_shape::IgnoreQueryParamsInResponse,
 4745   4746   
                                    ModelPl::Output
 4746   4747   
                                >
 4747   4748   
                            >::Output
 4748   4749   
                        >,
 4749   4750   
 4750         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4751         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4751  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4752  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4752   4753   
 4753   4754   
                    {
 4754   4755   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4755   4756   
        use ::aws_smithy_http_server::plugin::Plugin;
 4756   4757   
        let svc = crate::operation_shape::IgnoreQueryParamsInResponse::from_service(service);
 4757   4758   
        let svc = self.model_plugin.apply(svc);
 4758   4759   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4759   4760   
            .apply(svc);
 4760   4761   
        let svc = self.http_plugin.apply(svc);
 4761   4762   
        self.ignore_query_params_in_response_custom(svc)
 4762   4763   
    }
 4763   4764   
 4764   4765   
    /// Sets the [`IgnoreQueryParamsInResponse`](crate::operation_shape::IgnoreQueryParamsInResponse) to a custom [`Service`](tower::Service).
 4765   4766   
    /// not constrained by the Smithy contract.
 4766   4767   
    fn ignore_query_params_in_response_custom<S>(mut self, svc: S) -> Self
 4767   4768   
    where
 4768   4769   
        S: ::tower::Service<
 4769         -
                ::http::Request<Body>,
 4770         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4770  +
                ::http_1x::Request<Body>,
        4771  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4771   4772   
                Error = ::std::convert::Infallible,
 4772   4773   
            > + Clone
 4773   4774   
            + Send
 4774   4775   
            + 'static,
 4775   4776   
        S::Future: Send + 'static,
 4776   4777   
    {
 4777   4778   
        self.ignore_query_params_in_response =
 4778   4779   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 4779   4780   
        self
 4780   4781   
    }
@@ -4804,4805 +4865,4866 @@
 4824   4825   
                            <
 4825   4826   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4826   4827   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4827   4828   
                                    RestJson<L>,
 4828   4829   
                                    crate::operation_shape::InputAndOutputWithHeaders,
 4829   4830   
                                    ModelPl::Output
 4830   4831   
                                >
 4831   4832   
                            >::Output
 4832   4833   
                        >,
 4833   4834   
 4834         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4835         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4835  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4836  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4836   4837   
 4837   4838   
                    {
 4838   4839   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4839   4840   
        use ::aws_smithy_http_server::plugin::Plugin;
 4840   4841   
        let svc = crate::operation_shape::InputAndOutputWithHeaders::from_handler(handler);
 4841   4842   
        let svc = self.model_plugin.apply(svc);
 4842   4843   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4843   4844   
            .apply(svc);
 4844   4845   
        let svc = self.http_plugin.apply(svc);
 4845   4846   
        self.input_and_output_with_headers_custom(svc)
@@ -4871,4872 +4951,4952 @@
 4891   4892   
                            <
 4892   4893   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4893   4894   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4894   4895   
                                    RestJson<L>,
 4895   4896   
                                    crate::operation_shape::InputAndOutputWithHeaders,
 4896   4897   
                                    ModelPl::Output
 4897   4898   
                                >
 4898   4899   
                            >::Output
 4899   4900   
                        >,
 4900   4901   
 4901         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4902         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4902  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4903  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4903   4904   
 4904   4905   
                    {
 4905   4906   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4906   4907   
        use ::aws_smithy_http_server::plugin::Plugin;
 4907   4908   
        let svc = crate::operation_shape::InputAndOutputWithHeaders::from_service(service);
 4908   4909   
        let svc = self.model_plugin.apply(svc);
 4909   4910   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4910   4911   
            .apply(svc);
 4911   4912   
        let svc = self.http_plugin.apply(svc);
 4912   4913   
        self.input_and_output_with_headers_custom(svc)
 4913   4914   
    }
 4914   4915   
 4915   4916   
    /// Sets the [`InputAndOutputWithHeaders`](crate::operation_shape::InputAndOutputWithHeaders) to a custom [`Service`](tower::Service).
 4916   4917   
    /// not constrained by the Smithy contract.
 4917   4918   
    fn input_and_output_with_headers_custom<S>(mut self, svc: S) -> Self
 4918   4919   
    where
 4919   4920   
        S: ::tower::Service<
 4920         -
                ::http::Request<Body>,
 4921         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        4921  +
                ::http_1x::Request<Body>,
        4922  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 4922   4923   
                Error = ::std::convert::Infallible,
 4923   4924   
            > + Clone
 4924   4925   
            + Send
 4925   4926   
            + 'static,
 4926   4927   
        S::Future: Send + 'static,
 4927   4928   
    {
 4928   4929   
        self.input_and_output_with_headers =
 4929   4930   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 4930   4931   
        self
 4931   4932   
    }
@@ -4955,4956 +5016,5017 @@
 4975   4976   
                            <
 4976   4977   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 4977   4978   
                                as ::aws_smithy_http_server::plugin::Plugin<
 4978   4979   
                                    RestJson<L>,
 4979   4980   
                                    crate::operation_shape::JsonBlobs,
 4980   4981   
                                    ModelPl::Output
 4981   4982   
                                >
 4982   4983   
                            >::Output
 4983   4984   
                        >,
 4984   4985   
 4985         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 4986         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        4986  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        4987  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 4987   4988   
 4988   4989   
                    {
 4989   4990   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 4990   4991   
        use ::aws_smithy_http_server::plugin::Plugin;
 4991   4992   
        let svc = crate::operation_shape::JsonBlobs::from_handler(handler);
 4992   4993   
        let svc = self.model_plugin.apply(svc);
 4993   4994   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 4994   4995   
            .apply(svc);
 4995   4996   
        let svc = self.http_plugin.apply(svc);
 4996   4997   
        self.json_blobs_custom(svc)
@@ -5022,5023 +5102,5103 @@
 5042   5043   
                            <
 5043   5044   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5044   5045   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5045   5046   
                                    RestJson<L>,
 5046   5047   
                                    crate::operation_shape::JsonBlobs,
 5047   5048   
                                    ModelPl::Output
 5048   5049   
                                >
 5049   5050   
                            >::Output
 5050   5051   
                        >,
 5051   5052   
 5052         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5053         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5053  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5054  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5054   5055   
 5055   5056   
                    {
 5056   5057   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5057   5058   
        use ::aws_smithy_http_server::plugin::Plugin;
 5058   5059   
        let svc = crate::operation_shape::JsonBlobs::from_service(service);
 5059   5060   
        let svc = self.model_plugin.apply(svc);
 5060   5061   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5061   5062   
            .apply(svc);
 5062   5063   
        let svc = self.http_plugin.apply(svc);
 5063   5064   
        self.json_blobs_custom(svc)
 5064   5065   
    }
 5065   5066   
 5066   5067   
    /// Sets the [`JsonBlobs`](crate::operation_shape::JsonBlobs) to a custom [`Service`](tower::Service).
 5067   5068   
    /// not constrained by the Smithy contract.
 5068   5069   
    fn json_blobs_custom<S>(mut self, svc: S) -> Self
 5069   5070   
    where
 5070   5071   
        S: ::tower::Service<
 5071         -
                ::http::Request<Body>,
 5072         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5072  +
                ::http_1x::Request<Body>,
        5073  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5073   5074   
                Error = ::std::convert::Infallible,
 5074   5075   
            > + Clone
 5075   5076   
            + Send
 5076   5077   
            + 'static,
 5077   5078   
        S::Future: Send + 'static,
 5078   5079   
    {
 5079   5080   
        self.json_blobs = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5080   5081   
        self
 5081   5082   
    }
 5082   5083
@@ -5105,5106 +5166,5167 @@
 5125   5126   
                            <
 5126   5127   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5127   5128   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5128   5129   
                                    RestJson<L>,
 5129   5130   
                                    crate::operation_shape::JsonEnums,
 5130   5131   
                                    ModelPl::Output
 5131   5132   
                                >
 5132   5133   
                            >::Output
 5133   5134   
                        >,
 5134   5135   
 5135         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5136         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5136  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5137  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5137   5138   
 5138   5139   
                    {
 5139   5140   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5140   5141   
        use ::aws_smithy_http_server::plugin::Plugin;
 5141   5142   
        let svc = crate::operation_shape::JsonEnums::from_handler(handler);
 5142   5143   
        let svc = self.model_plugin.apply(svc);
 5143   5144   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5144   5145   
            .apply(svc);
 5145   5146   
        let svc = self.http_plugin.apply(svc);
 5146   5147   
        self.json_enums_custom(svc)
@@ -5172,5173 +5252,5253 @@
 5192   5193   
                            <
 5193   5194   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5194   5195   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5195   5196   
                                    RestJson<L>,
 5196   5197   
                                    crate::operation_shape::JsonEnums,
 5197   5198   
                                    ModelPl::Output
 5198   5199   
                                >
 5199   5200   
                            >::Output
 5200   5201   
                        >,
 5201   5202   
 5202         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5203         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5203  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5204  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5204   5205   
 5205   5206   
                    {
 5206   5207   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5207   5208   
        use ::aws_smithy_http_server::plugin::Plugin;
 5208   5209   
        let svc = crate::operation_shape::JsonEnums::from_service(service);
 5209   5210   
        let svc = self.model_plugin.apply(svc);
 5210   5211   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5211   5212   
            .apply(svc);
 5212   5213   
        let svc = self.http_plugin.apply(svc);
 5213   5214   
        self.json_enums_custom(svc)
 5214   5215   
    }
 5215   5216   
 5216   5217   
    /// Sets the [`JsonEnums`](crate::operation_shape::JsonEnums) to a custom [`Service`](tower::Service).
 5217   5218   
    /// not constrained by the Smithy contract.
 5218   5219   
    fn json_enums_custom<S>(mut self, svc: S) -> Self
 5219   5220   
    where
 5220   5221   
        S: ::tower::Service<
 5221         -
                ::http::Request<Body>,
 5222         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5222  +
                ::http_1x::Request<Body>,
        5223  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5223   5224   
                Error = ::std::convert::Infallible,
 5224   5225   
            > + Clone
 5225   5226   
            + Send
 5226   5227   
            + 'static,
 5227   5228   
        S::Future: Send + 'static,
 5228   5229   
    {
 5229   5230   
        self.json_enums = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5230   5231   
        self
 5231   5232   
    }
 5232   5233
@@ -5255,5256 +5316,5317 @@
 5275   5276   
                            <
 5276   5277   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5277   5278   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5278   5279   
                                    RestJson<L>,
 5279   5280   
                                    crate::operation_shape::JsonIntEnums,
 5280   5281   
                                    ModelPl::Output
 5281   5282   
                                >
 5282   5283   
                            >::Output
 5283   5284   
                        >,
 5284   5285   
 5285         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5286         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5286  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5287  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5287   5288   
 5288   5289   
                    {
 5289   5290   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5290   5291   
        use ::aws_smithy_http_server::plugin::Plugin;
 5291   5292   
        let svc = crate::operation_shape::JsonIntEnums::from_handler(handler);
 5292   5293   
        let svc = self.model_plugin.apply(svc);
 5293   5294   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5294   5295   
            .apply(svc);
 5295   5296   
        let svc = self.http_plugin.apply(svc);
 5296   5297   
        self.json_int_enums_custom(svc)
@@ -5322,5323 +5402,5403 @@
 5342   5343   
                            <
 5343   5344   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5344   5345   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5345   5346   
                                    RestJson<L>,
 5346   5347   
                                    crate::operation_shape::JsonIntEnums,
 5347   5348   
                                    ModelPl::Output
 5348   5349   
                                >
 5349   5350   
                            >::Output
 5350   5351   
                        >,
 5351   5352   
 5352         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5353         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5353  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5354  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5354   5355   
 5355   5356   
                    {
 5356   5357   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5357   5358   
        use ::aws_smithy_http_server::plugin::Plugin;
 5358   5359   
        let svc = crate::operation_shape::JsonIntEnums::from_service(service);
 5359   5360   
        let svc = self.model_plugin.apply(svc);
 5360   5361   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5361   5362   
            .apply(svc);
 5362   5363   
        let svc = self.http_plugin.apply(svc);
 5363   5364   
        self.json_int_enums_custom(svc)
 5364   5365   
    }
 5365   5366   
 5366   5367   
    /// Sets the [`JsonIntEnums`](crate::operation_shape::JsonIntEnums) to a custom [`Service`](tower::Service).
 5367   5368   
    /// not constrained by the Smithy contract.
 5368   5369   
    fn json_int_enums_custom<S>(mut self, svc: S) -> Self
 5369   5370   
    where
 5370   5371   
        S: ::tower::Service<
 5371         -
                ::http::Request<Body>,
 5372         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5372  +
                ::http_1x::Request<Body>,
        5373  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5373   5374   
                Error = ::std::convert::Infallible,
 5374   5375   
            > + Clone
 5375   5376   
            + Send
 5376   5377   
            + 'static,
 5377   5378   
        S::Future: Send + 'static,
 5378   5379   
    {
 5379   5380   
        self.json_int_enums = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5380   5381   
        self
 5381   5382   
    }
 5382   5383
@@ -5405,5406 +5466,5467 @@
 5425   5426   
                            <
 5426   5427   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5427   5428   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5428   5429   
                                    RestJson<L>,
 5429   5430   
                                    crate::operation_shape::JsonLists,
 5430   5431   
                                    ModelPl::Output
 5431   5432   
                                >
 5432   5433   
                            >::Output
 5433   5434   
                        >,
 5434   5435   
 5435         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5436         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5436  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5437  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5437   5438   
 5438   5439   
                    {
 5439   5440   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5440   5441   
        use ::aws_smithy_http_server::plugin::Plugin;
 5441   5442   
        let svc = crate::operation_shape::JsonLists::from_handler(handler);
 5442   5443   
        let svc = self.model_plugin.apply(svc);
 5443   5444   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5444   5445   
            .apply(svc);
 5445   5446   
        let svc = self.http_plugin.apply(svc);
 5446   5447   
        self.json_lists_custom(svc)
@@ -5472,5473 +5552,5553 @@
 5492   5493   
                            <
 5493   5494   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5494   5495   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5495   5496   
                                    RestJson<L>,
 5496   5497   
                                    crate::operation_shape::JsonLists,
 5497   5498   
                                    ModelPl::Output
 5498   5499   
                                >
 5499   5500   
                            >::Output
 5500   5501   
                        >,
 5501   5502   
 5502         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5503         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5503  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5504  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5504   5505   
 5505   5506   
                    {
 5506   5507   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5507   5508   
        use ::aws_smithy_http_server::plugin::Plugin;
 5508   5509   
        let svc = crate::operation_shape::JsonLists::from_service(service);
 5509   5510   
        let svc = self.model_plugin.apply(svc);
 5510   5511   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5511   5512   
            .apply(svc);
 5512   5513   
        let svc = self.http_plugin.apply(svc);
 5513   5514   
        self.json_lists_custom(svc)
 5514   5515   
    }
 5515   5516   
 5516   5517   
    /// Sets the [`JsonLists`](crate::operation_shape::JsonLists) to a custom [`Service`](tower::Service).
 5517   5518   
    /// not constrained by the Smithy contract.
 5518   5519   
    fn json_lists_custom<S>(mut self, svc: S) -> Self
 5519   5520   
    where
 5520   5521   
        S: ::tower::Service<
 5521         -
                ::http::Request<Body>,
 5522         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5522  +
                ::http_1x::Request<Body>,
        5523  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5523   5524   
                Error = ::std::convert::Infallible,
 5524   5525   
            > + Clone
 5525   5526   
            + Send
 5526   5527   
            + 'static,
 5527   5528   
        S::Future: Send + 'static,
 5528   5529   
    {
 5529   5530   
        self.json_lists = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5530   5531   
        self
 5531   5532   
    }
 5532   5533
@@ -5555,5556 +5616,5617 @@
 5575   5576   
                            <
 5576   5577   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5577   5578   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5578   5579   
                                    RestJson<L>,
 5579   5580   
                                    crate::operation_shape::JsonMaps,
 5580   5581   
                                    ModelPl::Output
 5581   5582   
                                >
 5582   5583   
                            >::Output
 5583   5584   
                        >,
 5584   5585   
 5585         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5586         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5586  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5587  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5587   5588   
 5588   5589   
                    {
 5589   5590   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5590   5591   
        use ::aws_smithy_http_server::plugin::Plugin;
 5591   5592   
        let svc = crate::operation_shape::JsonMaps::from_handler(handler);
 5592   5593   
        let svc = self.model_plugin.apply(svc);
 5593   5594   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5594   5595   
            .apply(svc);
 5595   5596   
        let svc = self.http_plugin.apply(svc);
 5596   5597   
        self.json_maps_custom(svc)
@@ -5622,5623 +5702,5703 @@
 5642   5643   
                            <
 5643   5644   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5644   5645   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5645   5646   
                                    RestJson<L>,
 5646   5647   
                                    crate::operation_shape::JsonMaps,
 5647   5648   
                                    ModelPl::Output
 5648   5649   
                                >
 5649   5650   
                            >::Output
 5650   5651   
                        >,
 5651   5652   
 5652         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5653         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5653  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5654  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5654   5655   
 5655   5656   
                    {
 5656   5657   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5657   5658   
        use ::aws_smithy_http_server::plugin::Plugin;
 5658   5659   
        let svc = crate::operation_shape::JsonMaps::from_service(service);
 5659   5660   
        let svc = self.model_plugin.apply(svc);
 5660   5661   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5661   5662   
            .apply(svc);
 5662   5663   
        let svc = self.http_plugin.apply(svc);
 5663   5664   
        self.json_maps_custom(svc)
 5664   5665   
    }
 5665   5666   
 5666   5667   
    /// Sets the [`JsonMaps`](crate::operation_shape::JsonMaps) to a custom [`Service`](tower::Service).
 5667   5668   
    /// not constrained by the Smithy contract.
 5668   5669   
    fn json_maps_custom<S>(mut self, svc: S) -> Self
 5669   5670   
    where
 5670   5671   
        S: ::tower::Service<
 5671         -
                ::http::Request<Body>,
 5672         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5672  +
                ::http_1x::Request<Body>,
        5673  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5673   5674   
                Error = ::std::convert::Infallible,
 5674   5675   
            > + Clone
 5675   5676   
            + Send
 5676   5677   
            + 'static,
 5677   5678   
        S::Future: Send + 'static,
 5678   5679   
    {
 5679   5680   
        self.json_maps = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5680   5681   
        self
 5681   5682   
    }
 5682   5683
@@ -5705,5706 +5766,5767 @@
 5725   5726   
                            <
 5726   5727   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5727   5728   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5728   5729   
                                    RestJson<L>,
 5729   5730   
                                    crate::operation_shape::JsonTimestamps,
 5730   5731   
                                    ModelPl::Output
 5731   5732   
                                >
 5732   5733   
                            >::Output
 5733   5734   
                        >,
 5734   5735   
 5735         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5736         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5736  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5737  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5737   5738   
 5738   5739   
                    {
 5739   5740   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5740   5741   
        use ::aws_smithy_http_server::plugin::Plugin;
 5741   5742   
        let svc = crate::operation_shape::JsonTimestamps::from_handler(handler);
 5742   5743   
        let svc = self.model_plugin.apply(svc);
 5743   5744   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5744   5745   
            .apply(svc);
 5745   5746   
        let svc = self.http_plugin.apply(svc);
 5746   5747   
        self.json_timestamps_custom(svc)
@@ -5772,5773 +5852,5853 @@
 5792   5793   
                            <
 5793   5794   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5794   5795   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5795   5796   
                                    RestJson<L>,
 5796   5797   
                                    crate::operation_shape::JsonTimestamps,
 5797   5798   
                                    ModelPl::Output
 5798   5799   
                                >
 5799   5800   
                            >::Output
 5800   5801   
                        >,
 5801   5802   
 5802         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5803         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5803  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5804  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5804   5805   
 5805   5806   
                    {
 5806   5807   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5807   5808   
        use ::aws_smithy_http_server::plugin::Plugin;
 5808   5809   
        let svc = crate::operation_shape::JsonTimestamps::from_service(service);
 5809   5810   
        let svc = self.model_plugin.apply(svc);
 5810   5811   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5811   5812   
            .apply(svc);
 5812   5813   
        let svc = self.http_plugin.apply(svc);
 5813   5814   
        self.json_timestamps_custom(svc)
 5814   5815   
    }
 5815   5816   
 5816   5817   
    /// Sets the [`JsonTimestamps`](crate::operation_shape::JsonTimestamps) to a custom [`Service`](tower::Service).
 5817   5818   
    /// not constrained by the Smithy contract.
 5818   5819   
    fn json_timestamps_custom<S>(mut self, svc: S) -> Self
 5819   5820   
    where
 5820   5821   
        S: ::tower::Service<
 5821         -
                ::http::Request<Body>,
 5822         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5822  +
                ::http_1x::Request<Body>,
        5823  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5823   5824   
                Error = ::std::convert::Infallible,
 5824   5825   
            > + Clone
 5825   5826   
            + Send
 5826   5827   
            + 'static,
 5827   5828   
        S::Future: Send + 'static,
 5828   5829   
    {
 5829   5830   
        self.json_timestamps = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5830   5831   
        self
 5831   5832   
    }
 5832   5833
@@ -5855,5856 +5916,5917 @@
 5875   5876   
                            <
 5876   5877   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5877   5878   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5878   5879   
                                    RestJson<L>,
 5879   5880   
                                    crate::operation_shape::JsonUnions,
 5880   5881   
                                    ModelPl::Output
 5881   5882   
                                >
 5882   5883   
                            >::Output
 5883   5884   
                        >,
 5884   5885   
 5885         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5886         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5886  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5887  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5887   5888   
 5888   5889   
                    {
 5889   5890   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5890   5891   
        use ::aws_smithy_http_server::plugin::Plugin;
 5891   5892   
        let svc = crate::operation_shape::JsonUnions::from_handler(handler);
 5892   5893   
        let svc = self.model_plugin.apply(svc);
 5893   5894   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5894   5895   
            .apply(svc);
 5895   5896   
        let svc = self.http_plugin.apply(svc);
 5896   5897   
        self.json_unions_custom(svc)
@@ -5922,5923 +6002,6003 @@
 5942   5943   
                            <
 5943   5944   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 5944   5945   
                                as ::aws_smithy_http_server::plugin::Plugin<
 5945   5946   
                                    RestJson<L>,
 5946   5947   
                                    crate::operation_shape::JsonUnions,
 5947   5948   
                                    ModelPl::Output
 5948   5949   
                                >
 5949   5950   
                            >::Output
 5950   5951   
                        >,
 5951   5952   
 5952         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 5953         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        5953  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        5954  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 5954   5955   
 5955   5956   
                    {
 5956   5957   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 5957   5958   
        use ::aws_smithy_http_server::plugin::Plugin;
 5958   5959   
        let svc = crate::operation_shape::JsonUnions::from_service(service);
 5959   5960   
        let svc = self.model_plugin.apply(svc);
 5960   5961   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 5961   5962   
            .apply(svc);
 5962   5963   
        let svc = self.http_plugin.apply(svc);
 5963   5964   
        self.json_unions_custom(svc)
 5964   5965   
    }
 5965   5966   
 5966   5967   
    /// Sets the [`JsonUnions`](crate::operation_shape::JsonUnions) to a custom [`Service`](tower::Service).
 5967   5968   
    /// not constrained by the Smithy contract.
 5968   5969   
    fn json_unions_custom<S>(mut self, svc: S) -> Self
 5969   5970   
    where
 5970   5971   
        S: ::tower::Service<
 5971         -
                ::http::Request<Body>,
 5972         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        5972  +
                ::http_1x::Request<Body>,
        5973  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 5973   5974   
                Error = ::std::convert::Infallible,
 5974   5975   
            > + Clone
 5975   5976   
            + Send
 5976   5977   
            + 'static,
 5977   5978   
        S::Future: Send + 'static,
 5978   5979   
    {
 5979   5980   
        self.json_unions = Some(::aws_smithy_http_server::routing::Route::new(svc));
 5980   5981   
        self
 5981   5982   
    }
 5982   5983
@@ -6005,6006 +6066,6067 @@
 6025   6026   
                            <
 6026   6027   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6027   6028   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6028   6029   
                                    RestJson<L>,
 6029   6030   
                                    crate::operation_shape::MalformedAcceptWithBody,
 6030   6031   
                                    ModelPl::Output
 6031   6032   
                                >
 6032   6033   
                            >::Output
 6033   6034   
                        >,
 6034   6035   
 6035         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6036         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6036  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6037  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6037   6038   
 6038   6039   
                    {
 6039   6040   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6040   6041   
        use ::aws_smithy_http_server::plugin::Plugin;
 6041   6042   
        let svc = crate::operation_shape::MalformedAcceptWithBody::from_handler(handler);
 6042   6043   
        let svc = self.model_plugin.apply(svc);
 6043   6044   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6044   6045   
            .apply(svc);
 6045   6046   
        let svc = self.http_plugin.apply(svc);
 6046   6047   
        self.malformed_accept_with_body_custom(svc)
@@ -6072,6073 +6152,6153 @@
 6092   6093   
                            <
 6093   6094   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6094   6095   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6095   6096   
                                    RestJson<L>,
 6096   6097   
                                    crate::operation_shape::MalformedAcceptWithBody,
 6097   6098   
                                    ModelPl::Output
 6098   6099   
                                >
 6099   6100   
                            >::Output
 6100   6101   
                        >,
 6101   6102   
 6102         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6103         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6103  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6104  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6104   6105   
 6105   6106   
                    {
 6106   6107   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6107   6108   
        use ::aws_smithy_http_server::plugin::Plugin;
 6108   6109   
        let svc = crate::operation_shape::MalformedAcceptWithBody::from_service(service);
 6109   6110   
        let svc = self.model_plugin.apply(svc);
 6110   6111   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6111   6112   
            .apply(svc);
 6112   6113   
        let svc = self.http_plugin.apply(svc);
 6113   6114   
        self.malformed_accept_with_body_custom(svc)
 6114   6115   
    }
 6115   6116   
 6116   6117   
    /// Sets the [`MalformedAcceptWithBody`](crate::operation_shape::MalformedAcceptWithBody) to a custom [`Service`](tower::Service).
 6117   6118   
    /// not constrained by the Smithy contract.
 6118   6119   
    fn malformed_accept_with_body_custom<S>(mut self, svc: S) -> Self
 6119   6120   
    where
 6120   6121   
        S: ::tower::Service<
 6121         -
                ::http::Request<Body>,
 6122         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        6122  +
                ::http_1x::Request<Body>,
        6123  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 6123   6124   
                Error = ::std::convert::Infallible,
 6124   6125   
            > + Clone
 6125   6126   
            + Send
 6126   6127   
            + 'static,
 6127   6128   
        S::Future: Send + 'static,
 6128   6129   
    {
 6129   6130   
        self.malformed_accept_with_body = Some(::aws_smithy_http_server::routing::Route::new(svc));
 6130   6131   
        self
 6131   6132   
    }
 6132   6133
@@ -6155,6156 +6216,6217 @@
 6175   6176   
                            <
 6176   6177   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6177   6178   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6178   6179   
                                    RestJson<L>,
 6179   6180   
                                    crate::operation_shape::MalformedAcceptWithGenericString,
 6180   6181   
                                    ModelPl::Output
 6181   6182   
                                >
 6182   6183   
                            >::Output
 6183   6184   
                        >,
 6184   6185   
 6185         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6186         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6186  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6187  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6187   6188   
 6188   6189   
                    {
 6189   6190   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6190   6191   
        use ::aws_smithy_http_server::plugin::Plugin;
 6191   6192   
        let svc = crate::operation_shape::MalformedAcceptWithGenericString::from_handler(handler);
 6192   6193   
        let svc = self.model_plugin.apply(svc);
 6193   6194   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6194   6195   
            .apply(svc);
 6195   6196   
        let svc = self.http_plugin.apply(svc);
 6196   6197   
        self.malformed_accept_with_generic_string_custom(svc)
@@ -6222,6223 +6302,6303 @@
 6242   6243   
                            <
 6243   6244   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6244   6245   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6245   6246   
                                    RestJson<L>,
 6246   6247   
                                    crate::operation_shape::MalformedAcceptWithGenericString,
 6247   6248   
                                    ModelPl::Output
 6248   6249   
                                >
 6249   6250   
                            >::Output
 6250   6251   
                        >,
 6251   6252   
 6252         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6253         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6253  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6254  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6254   6255   
 6255   6256   
                    {
 6256   6257   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6257   6258   
        use ::aws_smithy_http_server::plugin::Plugin;
 6258   6259   
        let svc = crate::operation_shape::MalformedAcceptWithGenericString::from_service(service);
 6259   6260   
        let svc = self.model_plugin.apply(svc);
 6260   6261   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6261   6262   
            .apply(svc);
 6262   6263   
        let svc = self.http_plugin.apply(svc);
 6263   6264   
        self.malformed_accept_with_generic_string_custom(svc)
 6264   6265   
    }
 6265   6266   
 6266   6267   
    /// Sets the [`MalformedAcceptWithGenericString`](crate::operation_shape::MalformedAcceptWithGenericString) to a custom [`Service`](tower::Service).
 6267   6268   
    /// not constrained by the Smithy contract.
 6268   6269   
    fn malformed_accept_with_generic_string_custom<S>(mut self, svc: S) -> Self
 6269   6270   
    where
 6270   6271   
        S: ::tower::Service<
 6271         -
                ::http::Request<Body>,
 6272         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        6272  +
                ::http_1x::Request<Body>,
        6273  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 6273   6274   
                Error = ::std::convert::Infallible,
 6274   6275   
            > + Clone
 6275   6276   
            + Send
 6276   6277   
            + 'static,
 6277   6278   
        S::Future: Send + 'static,
 6278   6279   
    {
 6279   6280   
        self.malformed_accept_with_generic_string =
 6280   6281   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 6281   6282   
        self
 6282   6283   
    }
@@ -6306,6307 +6367,6368 @@
 6326   6327   
                            <
 6327   6328   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6328   6329   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6329   6330   
                                    RestJson<L>,
 6330   6331   
                                    crate::operation_shape::MalformedAcceptWithPayload,
 6331   6332   
                                    ModelPl::Output
 6332   6333   
                                >
 6333   6334   
                            >::Output
 6334   6335   
                        >,
 6335   6336   
 6336         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6337         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6337  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6338  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6338   6339   
 6339   6340   
                    {
 6340   6341   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6341   6342   
        use ::aws_smithy_http_server::plugin::Plugin;
 6342   6343   
        let svc = crate::operation_shape::MalformedAcceptWithPayload::from_handler(handler);
 6343   6344   
        let svc = self.model_plugin.apply(svc);
 6344   6345   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6345   6346   
            .apply(svc);
 6346   6347   
        let svc = self.http_plugin.apply(svc);
 6347   6348   
        self.malformed_accept_with_payload_custom(svc)
@@ -6373,6374 +6453,6454 @@
 6393   6394   
                            <
 6394   6395   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6395   6396   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6396   6397   
                                    RestJson<L>,
 6397   6398   
                                    crate::operation_shape::MalformedAcceptWithPayload,
 6398   6399   
                                    ModelPl::Output
 6399   6400   
                                >
 6400   6401   
                            >::Output
 6401   6402   
                        >,
 6402   6403   
 6403         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6404         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6404  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6405  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6405   6406   
 6406   6407   
                    {
 6407   6408   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6408   6409   
        use ::aws_smithy_http_server::plugin::Plugin;
 6409   6410   
        let svc = crate::operation_shape::MalformedAcceptWithPayload::from_service(service);
 6410   6411   
        let svc = self.model_plugin.apply(svc);
 6411   6412   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6412   6413   
            .apply(svc);
 6413   6414   
        let svc = self.http_plugin.apply(svc);
 6414   6415   
        self.malformed_accept_with_payload_custom(svc)
 6415   6416   
    }
 6416   6417   
 6417   6418   
    /// Sets the [`MalformedAcceptWithPayload`](crate::operation_shape::MalformedAcceptWithPayload) to a custom [`Service`](tower::Service).
 6418   6419   
    /// not constrained by the Smithy contract.
 6419   6420   
    fn malformed_accept_with_payload_custom<S>(mut self, svc: S) -> Self
 6420   6421   
    where
 6421   6422   
        S: ::tower::Service<
 6422         -
                ::http::Request<Body>,
 6423         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        6423  +
                ::http_1x::Request<Body>,
        6424  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 6424   6425   
                Error = ::std::convert::Infallible,
 6425   6426   
            > + Clone
 6426   6427   
            + Send
 6427   6428   
            + 'static,
 6428   6429   
        S::Future: Send + 'static,
 6429   6430   
    {
 6430   6431   
        self.malformed_accept_with_payload =
 6431   6432   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 6432   6433   
        self
 6433   6434   
    }
@@ -6457,6458 +6518,6519 @@
 6477   6478   
                            <
 6478   6479   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6479   6480   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6480   6481   
                                    RestJson<L>,
 6481   6482   
                                    crate::operation_shape::MalformedBlob,
 6482   6483   
                                    ModelPl::Output
 6483   6484   
                                >
 6484   6485   
                            >::Output
 6485   6486   
                        >,
 6486   6487   
 6487         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6488         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6488  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6489  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6489   6490   
 6490   6491   
                    {
 6491   6492   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6492   6493   
        use ::aws_smithy_http_server::plugin::Plugin;
 6493   6494   
        let svc = crate::operation_shape::MalformedBlob::from_handler(handler);
 6494   6495   
        let svc = self.model_plugin.apply(svc);
 6495   6496   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6496   6497   
            .apply(svc);
 6497   6498   
        let svc = self.http_plugin.apply(svc);
 6498   6499   
        self.malformed_blob_custom(svc)
@@ -6524,6525 +6604,6605 @@
 6544   6545   
                            <
 6545   6546   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6546   6547   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6547   6548   
                                    RestJson<L>,
 6548   6549   
                                    crate::operation_shape::MalformedBlob,
 6549   6550   
                                    ModelPl::Output
 6550   6551   
                                >
 6551   6552   
                            >::Output
 6552   6553   
                        >,
 6553   6554   
 6554         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6555         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6555  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6556  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6556   6557   
 6557   6558   
                    {
 6558   6559   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6559   6560   
        use ::aws_smithy_http_server::plugin::Plugin;
 6560   6561   
        let svc = crate::operation_shape::MalformedBlob::from_service(service);
 6561   6562   
        let svc = self.model_plugin.apply(svc);
 6562   6563   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6563   6564   
            .apply(svc);
 6564   6565   
        let svc = self.http_plugin.apply(svc);
 6565   6566   
        self.malformed_blob_custom(svc)
 6566   6567   
    }
 6567   6568   
 6568   6569   
    /// Sets the [`MalformedBlob`](crate::operation_shape::MalformedBlob) to a custom [`Service`](tower::Service).
 6569   6570   
    /// not constrained by the Smithy contract.
 6570   6571   
    fn malformed_blob_custom<S>(mut self, svc: S) -> Self
 6571   6572   
    where
 6572   6573   
        S: ::tower::Service<
 6573         -
                ::http::Request<Body>,
 6574         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        6574  +
                ::http_1x::Request<Body>,
        6575  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 6575   6576   
                Error = ::std::convert::Infallible,
 6576   6577   
            > + Clone
 6577   6578   
            + Send
 6578   6579   
            + 'static,
 6579   6580   
        S::Future: Send + 'static,
 6580   6581   
    {
 6581   6582   
        self.malformed_blob = Some(::aws_smithy_http_server::routing::Route::new(svc));
 6582   6583   
        self
 6583   6584   
    }
 6584   6585
@@ -6607,6608 +6668,6669 @@
 6627   6628   
                            <
 6628   6629   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6629   6630   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6630   6631   
                                    RestJson<L>,
 6631   6632   
                                    crate::operation_shape::MalformedBoolean,
 6632   6633   
                                    ModelPl::Output
 6633   6634   
                                >
 6634   6635   
                            >::Output
 6635   6636   
                        >,
 6636   6637   
 6637         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6638         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6638  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6639  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6639   6640   
 6640   6641   
                    {
 6641   6642   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6642   6643   
        use ::aws_smithy_http_server::plugin::Plugin;
 6643   6644   
        let svc = crate::operation_shape::MalformedBoolean::from_handler(handler);
 6644   6645   
        let svc = self.model_plugin.apply(svc);
 6645   6646   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6646   6647   
            .apply(svc);
 6647   6648   
        let svc = self.http_plugin.apply(svc);
 6648   6649   
        self.malformed_boolean_custom(svc)
@@ -6674,6675 +6754,6755 @@
 6694   6695   
                            <
 6695   6696   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6696   6697   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6697   6698   
                                    RestJson<L>,
 6698   6699   
                                    crate::operation_shape::MalformedBoolean,
 6699   6700   
                                    ModelPl::Output
 6700   6701   
                                >
 6701   6702   
                            >::Output
 6702   6703   
                        >,
 6703   6704   
 6704         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6705         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6705  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6706  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6706   6707   
 6707   6708   
                    {
 6708   6709   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6709   6710   
        use ::aws_smithy_http_server::plugin::Plugin;
 6710   6711   
        let svc = crate::operation_shape::MalformedBoolean::from_service(service);
 6711   6712   
        let svc = self.model_plugin.apply(svc);
 6712   6713   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6713   6714   
            .apply(svc);
 6714   6715   
        let svc = self.http_plugin.apply(svc);
 6715   6716   
        self.malformed_boolean_custom(svc)
 6716   6717   
    }
 6717   6718   
 6718   6719   
    /// Sets the [`MalformedBoolean`](crate::operation_shape::MalformedBoolean) to a custom [`Service`](tower::Service).
 6719   6720   
    /// not constrained by the Smithy contract.
 6720   6721   
    fn malformed_boolean_custom<S>(mut self, svc: S) -> Self
 6721   6722   
    where
 6722   6723   
        S: ::tower::Service<
 6723         -
                ::http::Request<Body>,
 6724         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        6724  +
                ::http_1x::Request<Body>,
        6725  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 6725   6726   
                Error = ::std::convert::Infallible,
 6726   6727   
            > + Clone
 6727   6728   
            + Send
 6728   6729   
            + 'static,
 6729   6730   
        S::Future: Send + 'static,
 6730   6731   
    {
 6731   6732   
        self.malformed_boolean = Some(::aws_smithy_http_server::routing::Route::new(svc));
 6732   6733   
        self
 6733   6734   
    }
 6734   6735
@@ -6757,6758 +6818,6819 @@
 6777   6778   
                            <
 6778   6779   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6779   6780   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6780   6781   
                                    RestJson<L>,
 6781   6782   
                                    crate::operation_shape::MalformedByte,
 6782   6783   
                                    ModelPl::Output
 6783   6784   
                                >
 6784   6785   
                            >::Output
 6785   6786   
                        >,
 6786   6787   
 6787         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6788         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6788  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6789  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6789   6790   
 6790   6791   
                    {
 6791   6792   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6792   6793   
        use ::aws_smithy_http_server::plugin::Plugin;
 6793   6794   
        let svc = crate::operation_shape::MalformedByte::from_handler(handler);
 6794   6795   
        let svc = self.model_plugin.apply(svc);
 6795   6796   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6796   6797   
            .apply(svc);
 6797   6798   
        let svc = self.http_plugin.apply(svc);
 6798   6799   
        self.malformed_byte_custom(svc)
@@ -6824,6825 +6904,6905 @@
 6844   6845   
                            <
 6845   6846   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6846   6847   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6847   6848   
                                    RestJson<L>,
 6848   6849   
                                    crate::operation_shape::MalformedByte,
 6849   6850   
                                    ModelPl::Output
 6850   6851   
                                >
 6851   6852   
                            >::Output
 6852   6853   
                        >,
 6853   6854   
 6854         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6855         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6855  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6856  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6856   6857   
 6857   6858   
                    {
 6858   6859   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6859   6860   
        use ::aws_smithy_http_server::plugin::Plugin;
 6860   6861   
        let svc = crate::operation_shape::MalformedByte::from_service(service);
 6861   6862   
        let svc = self.model_plugin.apply(svc);
 6862   6863   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6863   6864   
            .apply(svc);
 6864   6865   
        let svc = self.http_plugin.apply(svc);
 6865   6866   
        self.malformed_byte_custom(svc)
 6866   6867   
    }
 6867   6868   
 6868   6869   
    /// Sets the [`MalformedByte`](crate::operation_shape::MalformedByte) to a custom [`Service`](tower::Service).
 6869   6870   
    /// not constrained by the Smithy contract.
 6870   6871   
    fn malformed_byte_custom<S>(mut self, svc: S) -> Self
 6871   6872   
    where
 6872   6873   
        S: ::tower::Service<
 6873         -
                ::http::Request<Body>,
 6874         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        6874  +
                ::http_1x::Request<Body>,
        6875  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 6875   6876   
                Error = ::std::convert::Infallible,
 6876   6877   
            > + Clone
 6877   6878   
            + Send
 6878   6879   
            + 'static,
 6879   6880   
        S::Future: Send + 'static,
 6880   6881   
    {
 6881   6882   
        self.malformed_byte = Some(::aws_smithy_http_server::routing::Route::new(svc));
 6882   6883   
        self
 6883   6884   
    }
 6884   6885
@@ -6907,6908 +6968,6969 @@
 6927   6928   
                            <
 6928   6929   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6929   6930   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6930   6931   
                                    RestJson<L>,
 6931   6932   
                                    crate::operation_shape::MalformedContentTypeWithBody,
 6932   6933   
                                    ModelPl::Output
 6933   6934   
                                >
 6934   6935   
                            >::Output
 6935   6936   
                        >,
 6936   6937   
 6937         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 6938         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        6938  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        6939  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 6939   6940   
 6940   6941   
                    {
 6941   6942   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 6942   6943   
        use ::aws_smithy_http_server::plugin::Plugin;
 6943   6944   
        let svc = crate::operation_shape::MalformedContentTypeWithBody::from_handler(handler);
 6944   6945   
        let svc = self.model_plugin.apply(svc);
 6945   6946   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 6946   6947   
            .apply(svc);
 6947   6948   
        let svc = self.http_plugin.apply(svc);
 6948   6949   
        self.malformed_content_type_with_body_custom(svc)
@@ -6974,6975 +7054,7055 @@
 6994   6995   
                            <
 6995   6996   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 6996   6997   
                                as ::aws_smithy_http_server::plugin::Plugin<
 6997   6998   
                                    RestJson<L>,
 6998   6999   
                                    crate::operation_shape::MalformedContentTypeWithBody,
 6999   7000   
                                    ModelPl::Output
 7000   7001   
                                >
 7001   7002   
                            >::Output
 7002   7003   
                        >,
 7003   7004   
 7004         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7005         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7005  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7006  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7006   7007   
 7007   7008   
                    {
 7008   7009   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7009   7010   
        use ::aws_smithy_http_server::plugin::Plugin;
 7010   7011   
        let svc = crate::operation_shape::MalformedContentTypeWithBody::from_service(service);
 7011   7012   
        let svc = self.model_plugin.apply(svc);
 7012   7013   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7013   7014   
            .apply(svc);
 7014   7015   
        let svc = self.http_plugin.apply(svc);
 7015   7016   
        self.malformed_content_type_with_body_custom(svc)
 7016   7017   
    }
 7017   7018   
 7018   7019   
    /// Sets the [`MalformedContentTypeWithBody`](crate::operation_shape::MalformedContentTypeWithBody) to a custom [`Service`](tower::Service).
 7019   7020   
    /// not constrained by the Smithy contract.
 7020   7021   
    fn malformed_content_type_with_body_custom<S>(mut self, svc: S) -> Self
 7021   7022   
    where
 7022   7023   
        S: ::tower::Service<
 7023         -
                ::http::Request<Body>,
 7024         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7024  +
                ::http_1x::Request<Body>,
        7025  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7025   7026   
                Error = ::std::convert::Infallible,
 7026   7027   
            > + Clone
 7027   7028   
            + Send
 7028   7029   
            + 'static,
 7029   7030   
        S::Future: Send + 'static,
 7030   7031   
    {
 7031   7032   
        self.malformed_content_type_with_body =
 7032   7033   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 7033   7034   
        self
 7034   7035   
    }
@@ -7058,7059 +7119,7120 @@
 7078   7079   
                            <
 7079   7080   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7080   7081   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7081   7082   
                                    RestJson<L>,
 7082   7083   
                                    crate::operation_shape::MalformedContentTypeWithGenericString,
 7083   7084   
                                    ModelPl::Output
 7084   7085   
                                >
 7085   7086   
                            >::Output
 7086   7087   
                        >,
 7087   7088   
 7088         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7089         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7089  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7090  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7090   7091   
 7091   7092   
                    {
 7092   7093   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7093   7094   
        use ::aws_smithy_http_server::plugin::Plugin;
 7094   7095   
        let svc =
 7095   7096   
            crate::operation_shape::MalformedContentTypeWithGenericString::from_handler(handler);
 7096   7097   
        let svc = self.model_plugin.apply(svc);
 7097   7098   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7098   7099   
            .apply(svc);
 7099   7100   
        let svc = self.http_plugin.apply(svc);
@@ -7126,7127 +7207,7208 @@
 7146   7147   
                            <
 7147   7148   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7148   7149   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7149   7150   
                                    RestJson<L>,
 7150   7151   
                                    crate::operation_shape::MalformedContentTypeWithGenericString,
 7151   7152   
                                    ModelPl::Output
 7152   7153   
                                >
 7153   7154   
                            >::Output
 7154   7155   
                        >,
 7155   7156   
 7156         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7157         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7157  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7158  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7158   7159   
 7159   7160   
                    {
 7160   7161   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7161   7162   
        use ::aws_smithy_http_server::plugin::Plugin;
 7162   7163   
        let svc =
 7163   7164   
            crate::operation_shape::MalformedContentTypeWithGenericString::from_service(service);
 7164   7165   
        let svc = self.model_plugin.apply(svc);
 7165   7166   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7166   7167   
            .apply(svc);
 7167   7168   
        let svc = self.http_plugin.apply(svc);
 7168   7169   
        self.malformed_content_type_with_generic_string_custom(svc)
 7169   7170   
    }
 7170   7171   
 7171   7172   
    /// Sets the [`MalformedContentTypeWithGenericString`](crate::operation_shape::MalformedContentTypeWithGenericString) to a custom [`Service`](tower::Service).
 7172   7173   
    /// not constrained by the Smithy contract.
 7173   7174   
    fn malformed_content_type_with_generic_string_custom<S>(mut self, svc: S) -> Self
 7174   7175   
    where
 7175   7176   
        S: ::tower::Service<
 7176         -
                ::http::Request<Body>,
 7177         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7177  +
                ::http_1x::Request<Body>,
        7178  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7178   7179   
                Error = ::std::convert::Infallible,
 7179   7180   
            > + Clone
 7180   7181   
            + Send
 7181   7182   
            + 'static,
 7182   7183   
        S::Future: Send + 'static,
 7183   7184   
    {
 7184   7185   
        self.malformed_content_type_with_generic_string =
 7185   7186   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 7186   7187   
        self
 7187   7188   
    }
@@ -7211,7212 +7272,7273 @@
 7231   7232   
                            <
 7232   7233   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7233   7234   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7234   7235   
                                    RestJson<L>,
 7235   7236   
                                    crate::operation_shape::MalformedContentTypeWithoutBody,
 7236   7237   
                                    ModelPl::Output
 7237   7238   
                                >
 7238   7239   
                            >::Output
 7239   7240   
                        >,
 7240   7241   
 7241         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7242         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7242  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7243  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7243   7244   
 7244   7245   
                    {
 7245   7246   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7246   7247   
        use ::aws_smithy_http_server::plugin::Plugin;
 7247   7248   
        let svc = crate::operation_shape::MalformedContentTypeWithoutBody::from_handler(handler);
 7248   7249   
        let svc = self.model_plugin.apply(svc);
 7249   7250   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7250   7251   
            .apply(svc);
 7251   7252   
        let svc = self.http_plugin.apply(svc);
 7252   7253   
        self.malformed_content_type_without_body_custom(svc)
@@ -7278,7279 +7358,7359 @@
 7298   7299   
                            <
 7299   7300   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7300   7301   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7301   7302   
                                    RestJson<L>,
 7302   7303   
                                    crate::operation_shape::MalformedContentTypeWithoutBody,
 7303   7304   
                                    ModelPl::Output
 7304   7305   
                                >
 7305   7306   
                            >::Output
 7306   7307   
                        >,
 7307   7308   
 7308         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7309         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7309  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7310  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7310   7311   
 7311   7312   
                    {
 7312   7313   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7313   7314   
        use ::aws_smithy_http_server::plugin::Plugin;
 7314   7315   
        let svc = crate::operation_shape::MalformedContentTypeWithoutBody::from_service(service);
 7315   7316   
        let svc = self.model_plugin.apply(svc);
 7316   7317   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7317   7318   
            .apply(svc);
 7318   7319   
        let svc = self.http_plugin.apply(svc);
 7319   7320   
        self.malformed_content_type_without_body_custom(svc)
 7320   7321   
    }
 7321   7322   
 7322   7323   
    /// Sets the [`MalformedContentTypeWithoutBody`](crate::operation_shape::MalformedContentTypeWithoutBody) to a custom [`Service`](tower::Service).
 7323   7324   
    /// not constrained by the Smithy contract.
 7324   7325   
    fn malformed_content_type_without_body_custom<S>(mut self, svc: S) -> Self
 7325   7326   
    where
 7326   7327   
        S: ::tower::Service<
 7327         -
                ::http::Request<Body>,
 7328         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7328  +
                ::http_1x::Request<Body>,
        7329  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7329   7330   
                Error = ::std::convert::Infallible,
 7330   7331   
            > + Clone
 7331   7332   
            + Send
 7332   7333   
            + 'static,
 7333   7334   
        S::Future: Send + 'static,
 7334   7335   
    {
 7335   7336   
        self.malformed_content_type_without_body =
 7336   7337   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 7337   7338   
        self
 7338   7339   
    }
@@ -7362,7363 +7423,7424 @@
 7382   7383   
                            <
 7383   7384   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7384   7385   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7385   7386   
                                    RestJson<L>,
 7386   7387   
                                    crate::operation_shape::MalformedContentTypeWithoutBodyEmptyInput,
 7387   7388   
                                    ModelPl::Output
 7388   7389   
                                >
 7389   7390   
                            >::Output
 7390   7391   
                        >,
 7391   7392   
 7392         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7393         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7393  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7394  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7394   7395   
 7395   7396   
                    {
 7396   7397   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7397   7398   
        use ::aws_smithy_http_server::plugin::Plugin;
 7398   7399   
        let svc = crate::operation_shape::MalformedContentTypeWithoutBodyEmptyInput::from_handler(
 7399   7400   
            handler,
 7400   7401   
        );
 7401   7402   
        let svc = self.model_plugin.apply(svc);
 7402   7403   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7403   7404   
            .apply(svc);
@@ -7431,7432 +7513,7514 @@
 7451   7452   
                            <
 7452   7453   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7453   7454   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7454   7455   
                                    RestJson<L>,
 7455   7456   
                                    crate::operation_shape::MalformedContentTypeWithoutBodyEmptyInput,
 7456   7457   
                                    ModelPl::Output
 7457   7458   
                                >
 7458   7459   
                            >::Output
 7459   7460   
                        >,
 7460   7461   
 7461         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7462         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7462  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7463  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7463   7464   
 7464   7465   
                    {
 7465   7466   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7466   7467   
        use ::aws_smithy_http_server::plugin::Plugin;
 7467   7468   
        let svc = crate::operation_shape::MalformedContentTypeWithoutBodyEmptyInput::from_service(
 7468   7469   
            service,
 7469   7470   
        );
 7470   7471   
        let svc = self.model_plugin.apply(svc);
 7471   7472   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7472   7473   
            .apply(svc);
 7473   7474   
        let svc = self.http_plugin.apply(svc);
 7474   7475   
        self.malformed_content_type_without_body_empty_input_custom(svc)
 7475   7476   
    }
 7476   7477   
 7477   7478   
    /// Sets the [`MalformedContentTypeWithoutBodyEmptyInput`](crate::operation_shape::MalformedContentTypeWithoutBodyEmptyInput) to a custom [`Service`](tower::Service).
 7478   7479   
    /// not constrained by the Smithy contract.
 7479   7480   
    fn malformed_content_type_without_body_empty_input_custom<S>(mut self, svc: S) -> Self
 7480   7481   
    where
 7481   7482   
        S: ::tower::Service<
 7482         -
                ::http::Request<Body>,
 7483         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7483  +
                ::http_1x::Request<Body>,
        7484  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7484   7485   
                Error = ::std::convert::Infallible,
 7485   7486   
            > + Clone
 7486   7487   
            + Send
 7487   7488   
            + 'static,
 7488   7489   
        S::Future: Send + 'static,
 7489   7490   
    {
 7490   7491   
        self.malformed_content_type_without_body_empty_input =
 7491   7492   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 7492   7493   
        self
 7493   7494   
    }
@@ -7517,7518 +7578,7579 @@
 7537   7538   
                            <
 7538   7539   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7539   7540   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7540   7541   
                                    RestJson<L>,
 7541   7542   
                                    crate::operation_shape::MalformedContentTypeWithPayload,
 7542   7543   
                                    ModelPl::Output
 7543   7544   
                                >
 7544   7545   
                            >::Output
 7545   7546   
                        >,
 7546   7547   
 7547         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7548         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7548  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7549  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7549   7550   
 7550   7551   
                    {
 7551   7552   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7552   7553   
        use ::aws_smithy_http_server::plugin::Plugin;
 7553   7554   
        let svc = crate::operation_shape::MalformedContentTypeWithPayload::from_handler(handler);
 7554   7555   
        let svc = self.model_plugin.apply(svc);
 7555   7556   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7556   7557   
            .apply(svc);
 7557   7558   
        let svc = self.http_plugin.apply(svc);
 7558   7559   
        self.malformed_content_type_with_payload_custom(svc)
@@ -7584,7585 +7664,7665 @@
 7604   7605   
                            <
 7605   7606   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7606   7607   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7607   7608   
                                    RestJson<L>,
 7608   7609   
                                    crate::operation_shape::MalformedContentTypeWithPayload,
 7609   7610   
                                    ModelPl::Output
 7610   7611   
                                >
 7611   7612   
                            >::Output
 7612   7613   
                        >,
 7613   7614   
 7614         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7615         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7615  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7616  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7616   7617   
 7617   7618   
                    {
 7618   7619   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7619   7620   
        use ::aws_smithy_http_server::plugin::Plugin;
 7620   7621   
        let svc = crate::operation_shape::MalformedContentTypeWithPayload::from_service(service);
 7621   7622   
        let svc = self.model_plugin.apply(svc);
 7622   7623   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7623   7624   
            .apply(svc);
 7624   7625   
        let svc = self.http_plugin.apply(svc);
 7625   7626   
        self.malformed_content_type_with_payload_custom(svc)
 7626   7627   
    }
 7627   7628   
 7628   7629   
    /// Sets the [`MalformedContentTypeWithPayload`](crate::operation_shape::MalformedContentTypeWithPayload) to a custom [`Service`](tower::Service).
 7629   7630   
    /// not constrained by the Smithy contract.
 7630   7631   
    fn malformed_content_type_with_payload_custom<S>(mut self, svc: S) -> Self
 7631   7632   
    where
 7632   7633   
        S: ::tower::Service<
 7633         -
                ::http::Request<Body>,
 7634         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7634  +
                ::http_1x::Request<Body>,
        7635  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7635   7636   
                Error = ::std::convert::Infallible,
 7636   7637   
            > + Clone
 7637   7638   
            + Send
 7638   7639   
            + 'static,
 7639   7640   
        S::Future: Send + 'static,
 7640   7641   
    {
 7641   7642   
        self.malformed_content_type_with_payload =
 7642   7643   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 7643   7644   
        self
 7644   7645   
    }
@@ -7668,7669 +7729,7730 @@
 7688   7689   
                            <
 7689   7690   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7690   7691   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7691   7692   
                                    RestJson<L>,
 7692   7693   
                                    crate::operation_shape::MalformedDouble,
 7693   7694   
                                    ModelPl::Output
 7694   7695   
                                >
 7695   7696   
                            >::Output
 7696   7697   
                        >,
 7697   7698   
 7698         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7699         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7699  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7700  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7700   7701   
 7701   7702   
                    {
 7702   7703   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7703   7704   
        use ::aws_smithy_http_server::plugin::Plugin;
 7704   7705   
        let svc = crate::operation_shape::MalformedDouble::from_handler(handler);
 7705   7706   
        let svc = self.model_plugin.apply(svc);
 7706   7707   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7707   7708   
            .apply(svc);
 7708   7709   
        let svc = self.http_plugin.apply(svc);
 7709   7710   
        self.malformed_double_custom(svc)
@@ -7735,7736 +7815,7816 @@
 7755   7756   
                            <
 7756   7757   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7757   7758   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7758   7759   
                                    RestJson<L>,
 7759   7760   
                                    crate::operation_shape::MalformedDouble,
 7760   7761   
                                    ModelPl::Output
 7761   7762   
                                >
 7762   7763   
                            >::Output
 7763   7764   
                        >,
 7764   7765   
 7765         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7766         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7766  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7767  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7767   7768   
 7768   7769   
                    {
 7769   7770   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7770   7771   
        use ::aws_smithy_http_server::plugin::Plugin;
 7771   7772   
        let svc = crate::operation_shape::MalformedDouble::from_service(service);
 7772   7773   
        let svc = self.model_plugin.apply(svc);
 7773   7774   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7774   7775   
            .apply(svc);
 7775   7776   
        let svc = self.http_plugin.apply(svc);
 7776   7777   
        self.malformed_double_custom(svc)
 7777   7778   
    }
 7778   7779   
 7779   7780   
    /// Sets the [`MalformedDouble`](crate::operation_shape::MalformedDouble) to a custom [`Service`](tower::Service).
 7780   7781   
    /// not constrained by the Smithy contract.
 7781   7782   
    fn malformed_double_custom<S>(mut self, svc: S) -> Self
 7782   7783   
    where
 7783   7784   
        S: ::tower::Service<
 7784         -
                ::http::Request<Body>,
 7785         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7785  +
                ::http_1x::Request<Body>,
        7786  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7786   7787   
                Error = ::std::convert::Infallible,
 7787   7788   
            > + Clone
 7788   7789   
            + Send
 7789   7790   
            + 'static,
 7790   7791   
        S::Future: Send + 'static,
 7791   7792   
    {
 7792   7793   
        self.malformed_double = Some(::aws_smithy_http_server::routing::Route::new(svc));
 7793   7794   
        self
 7794   7795   
    }
 7795   7796
@@ -7818,7819 +7879,7880 @@
 7838   7839   
                            <
 7839   7840   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7840   7841   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7841   7842   
                                    RestJson<L>,
 7842   7843   
                                    crate::operation_shape::MalformedFloat,
 7843   7844   
                                    ModelPl::Output
 7844   7845   
                                >
 7845   7846   
                            >::Output
 7846   7847   
                        >,
 7847   7848   
 7848         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7849         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7849  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7850  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7850   7851   
 7851   7852   
                    {
 7852   7853   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7853   7854   
        use ::aws_smithy_http_server::plugin::Plugin;
 7854   7855   
        let svc = crate::operation_shape::MalformedFloat::from_handler(handler);
 7855   7856   
        let svc = self.model_plugin.apply(svc);
 7856   7857   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7857   7858   
            .apply(svc);
 7858   7859   
        let svc = self.http_plugin.apply(svc);
 7859   7860   
        self.malformed_float_custom(svc)
@@ -7885,7886 +7965,7966 @@
 7905   7906   
                            <
 7906   7907   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7907   7908   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7908   7909   
                                    RestJson<L>,
 7909   7910   
                                    crate::operation_shape::MalformedFloat,
 7910   7911   
                                    ModelPl::Output
 7911   7912   
                                >
 7912   7913   
                            >::Output
 7913   7914   
                        >,
 7914   7915   
 7915         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7916         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7916  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        7917  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 7917   7918   
 7918   7919   
                    {
 7919   7920   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 7920   7921   
        use ::aws_smithy_http_server::plugin::Plugin;
 7921   7922   
        let svc = crate::operation_shape::MalformedFloat::from_service(service);
 7922   7923   
        let svc = self.model_plugin.apply(svc);
 7923   7924   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 7924   7925   
            .apply(svc);
 7925   7926   
        let svc = self.http_plugin.apply(svc);
 7926   7927   
        self.malformed_float_custom(svc)
 7927   7928   
    }
 7928   7929   
 7929   7930   
    /// Sets the [`MalformedFloat`](crate::operation_shape::MalformedFloat) to a custom [`Service`](tower::Service).
 7930   7931   
    /// not constrained by the Smithy contract.
 7931   7932   
    fn malformed_float_custom<S>(mut self, svc: S) -> Self
 7932   7933   
    where
 7933   7934   
        S: ::tower::Service<
 7934         -
                ::http::Request<Body>,
 7935         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        7935  +
                ::http_1x::Request<Body>,
        7936  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 7936   7937   
                Error = ::std::convert::Infallible,
 7937   7938   
            > + Clone
 7938   7939   
            + Send
 7939   7940   
            + 'static,
 7940   7941   
        S::Future: Send + 'static,
 7941   7942   
    {
 7942   7943   
        self.malformed_float = Some(::aws_smithy_http_server::routing::Route::new(svc));
 7943   7944   
        self
 7944   7945   
    }
 7945   7946
@@ -7968,7969 +8029,8030 @@
 7988   7989   
                            <
 7989   7990   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 7990   7991   
                                as ::aws_smithy_http_server::plugin::Plugin<
 7991   7992   
                                    RestJson<L>,
 7992   7993   
                                    crate::operation_shape::MalformedInteger,
 7993   7994   
                                    ModelPl::Output
 7994   7995   
                                >
 7995   7996   
                            >::Output
 7996   7997   
                        >,
 7997   7998   
 7998         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 7999         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        7999  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8000  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8000   8001   
 8001   8002   
                    {
 8002   8003   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8003   8004   
        use ::aws_smithy_http_server::plugin::Plugin;
 8004   8005   
        let svc = crate::operation_shape::MalformedInteger::from_handler(handler);
 8005   8006   
        let svc = self.model_plugin.apply(svc);
 8006   8007   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8007   8008   
            .apply(svc);
 8008   8009   
        let svc = self.http_plugin.apply(svc);
 8009   8010   
        self.malformed_integer_custom(svc)
@@ -8035,8036 +8115,8116 @@
 8055   8056   
                            <
 8056   8057   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8057   8058   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8058   8059   
                                    RestJson<L>,
 8059   8060   
                                    crate::operation_shape::MalformedInteger,
 8060   8061   
                                    ModelPl::Output
 8061   8062   
                                >
 8062   8063   
                            >::Output
 8063   8064   
                        >,
 8064   8065   
 8065         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8066         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8066  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8067  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8067   8068   
 8068   8069   
                    {
 8069   8070   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8070   8071   
        use ::aws_smithy_http_server::plugin::Plugin;
 8071   8072   
        let svc = crate::operation_shape::MalformedInteger::from_service(service);
 8072   8073   
        let svc = self.model_plugin.apply(svc);
 8073   8074   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8074   8075   
            .apply(svc);
 8075   8076   
        let svc = self.http_plugin.apply(svc);
 8076   8077   
        self.malformed_integer_custom(svc)
 8077   8078   
    }
 8078   8079   
 8079   8080   
    /// Sets the [`MalformedInteger`](crate::operation_shape::MalformedInteger) to a custom [`Service`](tower::Service).
 8080   8081   
    /// not constrained by the Smithy contract.
 8081   8082   
    fn malformed_integer_custom<S>(mut self, svc: S) -> Self
 8082   8083   
    where
 8083   8084   
        S: ::tower::Service<
 8084         -
                ::http::Request<Body>,
 8085         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8085  +
                ::http_1x::Request<Body>,
        8086  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8086   8087   
                Error = ::std::convert::Infallible,
 8087   8088   
            > + Clone
 8088   8089   
            + Send
 8089   8090   
            + 'static,
 8090   8091   
        S::Future: Send + 'static,
 8091   8092   
    {
 8092   8093   
        self.malformed_integer = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8093   8094   
        self
 8094   8095   
    }
 8095   8096
@@ -8118,8119 +8179,8180 @@
 8138   8139   
                            <
 8139   8140   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8140   8141   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8141   8142   
                                    RestJson<L>,
 8142   8143   
                                    crate::operation_shape::MalformedList,
 8143   8144   
                                    ModelPl::Output
 8144   8145   
                                >
 8145   8146   
                            >::Output
 8146   8147   
                        >,
 8147   8148   
 8148         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8149         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8149  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8150  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8150   8151   
 8151   8152   
                    {
 8152   8153   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8153   8154   
        use ::aws_smithy_http_server::plugin::Plugin;
 8154   8155   
        let svc = crate::operation_shape::MalformedList::from_handler(handler);
 8155   8156   
        let svc = self.model_plugin.apply(svc);
 8156   8157   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8157   8158   
            .apply(svc);
 8158   8159   
        let svc = self.http_plugin.apply(svc);
 8159   8160   
        self.malformed_list_custom(svc)
@@ -8185,8186 +8265,8266 @@
 8205   8206   
                            <
 8206   8207   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8207   8208   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8208   8209   
                                    RestJson<L>,
 8209   8210   
                                    crate::operation_shape::MalformedList,
 8210   8211   
                                    ModelPl::Output
 8211   8212   
                                >
 8212   8213   
                            >::Output
 8213   8214   
                        >,
 8214   8215   
 8215         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8216         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8216  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8217  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8217   8218   
 8218   8219   
                    {
 8219   8220   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8220   8221   
        use ::aws_smithy_http_server::plugin::Plugin;
 8221   8222   
        let svc = crate::operation_shape::MalformedList::from_service(service);
 8222   8223   
        let svc = self.model_plugin.apply(svc);
 8223   8224   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8224   8225   
            .apply(svc);
 8225   8226   
        let svc = self.http_plugin.apply(svc);
 8226   8227   
        self.malformed_list_custom(svc)
 8227   8228   
    }
 8228   8229   
 8229   8230   
    /// Sets the [`MalformedList`](crate::operation_shape::MalformedList) to a custom [`Service`](tower::Service).
 8230   8231   
    /// not constrained by the Smithy contract.
 8231   8232   
    fn malformed_list_custom<S>(mut self, svc: S) -> Self
 8232   8233   
    where
 8233   8234   
        S: ::tower::Service<
 8234         -
                ::http::Request<Body>,
 8235         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8235  +
                ::http_1x::Request<Body>,
        8236  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8236   8237   
                Error = ::std::convert::Infallible,
 8237   8238   
            > + Clone
 8238   8239   
            + Send
 8239   8240   
            + 'static,
 8240   8241   
        S::Future: Send + 'static,
 8241   8242   
    {
 8242   8243   
        self.malformed_list = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8243   8244   
        self
 8244   8245   
    }
 8245   8246
@@ -8268,8269 +8329,8330 @@
 8288   8289   
                            <
 8289   8290   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8290   8291   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8291   8292   
                                    RestJson<L>,
 8292   8293   
                                    crate::operation_shape::MalformedLong,
 8293   8294   
                                    ModelPl::Output
 8294   8295   
                                >
 8295   8296   
                            >::Output
 8296   8297   
                        >,
 8297   8298   
 8298         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8299         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8299  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8300  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8300   8301   
 8301   8302   
                    {
 8302   8303   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8303   8304   
        use ::aws_smithy_http_server::plugin::Plugin;
 8304   8305   
        let svc = crate::operation_shape::MalformedLong::from_handler(handler);
 8305   8306   
        let svc = self.model_plugin.apply(svc);
 8306   8307   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8307   8308   
            .apply(svc);
 8308   8309   
        let svc = self.http_plugin.apply(svc);
 8309   8310   
        self.malformed_long_custom(svc)
@@ -8335,8336 +8415,8416 @@
 8355   8356   
                            <
 8356   8357   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8357   8358   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8358   8359   
                                    RestJson<L>,
 8359   8360   
                                    crate::operation_shape::MalformedLong,
 8360   8361   
                                    ModelPl::Output
 8361   8362   
                                >
 8362   8363   
                            >::Output
 8363   8364   
                        >,
 8364   8365   
 8365         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8366         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8366  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8367  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8367   8368   
 8368   8369   
                    {
 8369   8370   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8370   8371   
        use ::aws_smithy_http_server::plugin::Plugin;
 8371   8372   
        let svc = crate::operation_shape::MalformedLong::from_service(service);
 8372   8373   
        let svc = self.model_plugin.apply(svc);
 8373   8374   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8374   8375   
            .apply(svc);
 8375   8376   
        let svc = self.http_plugin.apply(svc);
 8376   8377   
        self.malformed_long_custom(svc)
 8377   8378   
    }
 8378   8379   
 8379   8380   
    /// Sets the [`MalformedLong`](crate::operation_shape::MalformedLong) to a custom [`Service`](tower::Service).
 8380   8381   
    /// not constrained by the Smithy contract.
 8381   8382   
    fn malformed_long_custom<S>(mut self, svc: S) -> Self
 8382   8383   
    where
 8383   8384   
        S: ::tower::Service<
 8384         -
                ::http::Request<Body>,
 8385         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8385  +
                ::http_1x::Request<Body>,
        8386  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8386   8387   
                Error = ::std::convert::Infallible,
 8387   8388   
            > + Clone
 8388   8389   
            + Send
 8389   8390   
            + 'static,
 8390   8391   
        S::Future: Send + 'static,
 8391   8392   
    {
 8392   8393   
        self.malformed_long = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8393   8394   
        self
 8394   8395   
    }
 8395   8396
@@ -8418,8419 +8479,8480 @@
 8438   8439   
                            <
 8439   8440   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8440   8441   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8441   8442   
                                    RestJson<L>,
 8442   8443   
                                    crate::operation_shape::MalformedMap,
 8443   8444   
                                    ModelPl::Output
 8444   8445   
                                >
 8445   8446   
                            >::Output
 8446   8447   
                        >,
 8447   8448   
 8448         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8449         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8449  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8450  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8450   8451   
 8451   8452   
                    {
 8452   8453   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8453   8454   
        use ::aws_smithy_http_server::plugin::Plugin;
 8454   8455   
        let svc = crate::operation_shape::MalformedMap::from_handler(handler);
 8455   8456   
        let svc = self.model_plugin.apply(svc);
 8456   8457   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8457   8458   
            .apply(svc);
 8458   8459   
        let svc = self.http_plugin.apply(svc);
 8459   8460   
        self.malformed_map_custom(svc)
@@ -8485,8486 +8565,8566 @@
 8505   8506   
                            <
 8506   8507   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8507   8508   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8508   8509   
                                    RestJson<L>,
 8509   8510   
                                    crate::operation_shape::MalformedMap,
 8510   8511   
                                    ModelPl::Output
 8511   8512   
                                >
 8512   8513   
                            >::Output
 8513   8514   
                        >,
 8514   8515   
 8515         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8516         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8516  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8517  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8517   8518   
 8518   8519   
                    {
 8519   8520   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8520   8521   
        use ::aws_smithy_http_server::plugin::Plugin;
 8521   8522   
        let svc = crate::operation_shape::MalformedMap::from_service(service);
 8522   8523   
        let svc = self.model_plugin.apply(svc);
 8523   8524   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8524   8525   
            .apply(svc);
 8525   8526   
        let svc = self.http_plugin.apply(svc);
 8526   8527   
        self.malformed_map_custom(svc)
 8527   8528   
    }
 8528   8529   
 8529   8530   
    /// Sets the [`MalformedMap`](crate::operation_shape::MalformedMap) to a custom [`Service`](tower::Service).
 8530   8531   
    /// not constrained by the Smithy contract.
 8531   8532   
    fn malformed_map_custom<S>(mut self, svc: S) -> Self
 8532   8533   
    where
 8533   8534   
        S: ::tower::Service<
 8534         -
                ::http::Request<Body>,
 8535         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8535  +
                ::http_1x::Request<Body>,
        8536  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8536   8537   
                Error = ::std::convert::Infallible,
 8537   8538   
            > + Clone
 8538   8539   
            + Send
 8539   8540   
            + 'static,
 8540   8541   
        S::Future: Send + 'static,
 8541   8542   
    {
 8542   8543   
        self.malformed_map = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8543   8544   
        self
 8544   8545   
    }
 8545   8546
@@ -8568,8569 +8629,8630 @@
 8588   8589   
                            <
 8589   8590   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8590   8591   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8591   8592   
                                    RestJson<L>,
 8592   8593   
                                    crate::operation_shape::MalformedRequestBody,
 8593   8594   
                                    ModelPl::Output
 8594   8595   
                                >
 8595   8596   
                            >::Output
 8596   8597   
                        >,
 8597   8598   
 8598         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8599         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8599  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8600  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8600   8601   
 8601   8602   
                    {
 8602   8603   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8603   8604   
        use ::aws_smithy_http_server::plugin::Plugin;
 8604   8605   
        let svc = crate::operation_shape::MalformedRequestBody::from_handler(handler);
 8605   8606   
        let svc = self.model_plugin.apply(svc);
 8606   8607   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8607   8608   
            .apply(svc);
 8608   8609   
        let svc = self.http_plugin.apply(svc);
 8609   8610   
        self.malformed_request_body_custom(svc)
@@ -8635,8636 +8715,8716 @@
 8655   8656   
                            <
 8656   8657   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8657   8658   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8658   8659   
                                    RestJson<L>,
 8659   8660   
                                    crate::operation_shape::MalformedRequestBody,
 8660   8661   
                                    ModelPl::Output
 8661   8662   
                                >
 8662   8663   
                            >::Output
 8663   8664   
                        >,
 8664   8665   
 8665         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8666         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8666  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8667  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8667   8668   
 8668   8669   
                    {
 8669   8670   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8670   8671   
        use ::aws_smithy_http_server::plugin::Plugin;
 8671   8672   
        let svc = crate::operation_shape::MalformedRequestBody::from_service(service);
 8672   8673   
        let svc = self.model_plugin.apply(svc);
 8673   8674   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8674   8675   
            .apply(svc);
 8675   8676   
        let svc = self.http_plugin.apply(svc);
 8676   8677   
        self.malformed_request_body_custom(svc)
 8677   8678   
    }
 8678   8679   
 8679   8680   
    /// Sets the [`MalformedRequestBody`](crate::operation_shape::MalformedRequestBody) to a custom [`Service`](tower::Service).
 8680   8681   
    /// not constrained by the Smithy contract.
 8681   8682   
    fn malformed_request_body_custom<S>(mut self, svc: S) -> Self
 8682   8683   
    where
 8683   8684   
        S: ::tower::Service<
 8684         -
                ::http::Request<Body>,
 8685         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8685  +
                ::http_1x::Request<Body>,
        8686  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8686   8687   
                Error = ::std::convert::Infallible,
 8687   8688   
            > + Clone
 8688   8689   
            + Send
 8689   8690   
            + 'static,
 8690   8691   
        S::Future: Send + 'static,
 8691   8692   
    {
 8692   8693   
        self.malformed_request_body = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8693   8694   
        self
 8694   8695   
    }
 8695   8696
@@ -8718,8719 +8779,8780 @@
 8738   8739   
                            <
 8739   8740   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8740   8741   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8741   8742   
                                    RestJson<L>,
 8742   8743   
                                    crate::operation_shape::MalformedShort,
 8743   8744   
                                    ModelPl::Output
 8744   8745   
                                >
 8745   8746   
                            >::Output
 8746   8747   
                        >,
 8747   8748   
 8748         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8749         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8749  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8750  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8750   8751   
 8751   8752   
                    {
 8752   8753   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8753   8754   
        use ::aws_smithy_http_server::plugin::Plugin;
 8754   8755   
        let svc = crate::operation_shape::MalformedShort::from_handler(handler);
 8755   8756   
        let svc = self.model_plugin.apply(svc);
 8756   8757   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8757   8758   
            .apply(svc);
 8758   8759   
        let svc = self.http_plugin.apply(svc);
 8759   8760   
        self.malformed_short_custom(svc)
@@ -8785,8786 +8865,8866 @@
 8805   8806   
                            <
 8806   8807   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8807   8808   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8808   8809   
                                    RestJson<L>,
 8809   8810   
                                    crate::operation_shape::MalformedShort,
 8810   8811   
                                    ModelPl::Output
 8811   8812   
                                >
 8812   8813   
                            >::Output
 8813   8814   
                        >,
 8814   8815   
 8815         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8816         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8816  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8817  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8817   8818   
 8818   8819   
                    {
 8819   8820   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8820   8821   
        use ::aws_smithy_http_server::plugin::Plugin;
 8821   8822   
        let svc = crate::operation_shape::MalformedShort::from_service(service);
 8822   8823   
        let svc = self.model_plugin.apply(svc);
 8823   8824   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8824   8825   
            .apply(svc);
 8825   8826   
        let svc = self.http_plugin.apply(svc);
 8826   8827   
        self.malformed_short_custom(svc)
 8827   8828   
    }
 8828   8829   
 8829   8830   
    /// Sets the [`MalformedShort`](crate::operation_shape::MalformedShort) to a custom [`Service`](tower::Service).
 8830   8831   
    /// not constrained by the Smithy contract.
 8831   8832   
    fn malformed_short_custom<S>(mut self, svc: S) -> Self
 8832   8833   
    where
 8833   8834   
        S: ::tower::Service<
 8834         -
                ::http::Request<Body>,
 8835         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8835  +
                ::http_1x::Request<Body>,
        8836  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8836   8837   
                Error = ::std::convert::Infallible,
 8837   8838   
            > + Clone
 8838   8839   
            + Send
 8839   8840   
            + 'static,
 8840   8841   
        S::Future: Send + 'static,
 8841   8842   
    {
 8842   8843   
        self.malformed_short = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8843   8844   
        self
 8844   8845   
    }
 8845   8846
@@ -8868,8869 +8929,8930 @@
 8888   8889   
                            <
 8889   8890   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8890   8891   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8891   8892   
                                    RestJson<L>,
 8892   8893   
                                    crate::operation_shape::MalformedString,
 8893   8894   
                                    ModelPl::Output
 8894   8895   
                                >
 8895   8896   
                            >::Output
 8896   8897   
                        >,
 8897   8898   
 8898         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8899         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8899  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8900  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8900   8901   
 8901   8902   
                    {
 8902   8903   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8903   8904   
        use ::aws_smithy_http_server::plugin::Plugin;
 8904   8905   
        let svc = crate::operation_shape::MalformedString::from_handler(handler);
 8905   8906   
        let svc = self.model_plugin.apply(svc);
 8906   8907   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8907   8908   
            .apply(svc);
 8908   8909   
        let svc = self.http_plugin.apply(svc);
 8909   8910   
        self.malformed_string_custom(svc)
@@ -8935,8936 +9015,9016 @@
 8955   8956   
                            <
 8956   8957   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 8957   8958   
                                as ::aws_smithy_http_server::plugin::Plugin<
 8958   8959   
                                    RestJson<L>,
 8959   8960   
                                    crate::operation_shape::MalformedString,
 8960   8961   
                                    ModelPl::Output
 8961   8962   
                                >
 8962   8963   
                            >::Output
 8963   8964   
                        >,
 8964   8965   
 8965         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 8966         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        8966  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        8967  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 8967   8968   
 8968   8969   
                    {
 8969   8970   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 8970   8971   
        use ::aws_smithy_http_server::plugin::Plugin;
 8971   8972   
        let svc = crate::operation_shape::MalformedString::from_service(service);
 8972   8973   
        let svc = self.model_plugin.apply(svc);
 8973   8974   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 8974   8975   
            .apply(svc);
 8975   8976   
        let svc = self.http_plugin.apply(svc);
 8976   8977   
        self.malformed_string_custom(svc)
 8977   8978   
    }
 8978   8979   
 8979   8980   
    /// Sets the [`MalformedString`](crate::operation_shape::MalformedString) to a custom [`Service`](tower::Service).
 8980   8981   
    /// not constrained by the Smithy contract.
 8981   8982   
    fn malformed_string_custom<S>(mut self, svc: S) -> Self
 8982   8983   
    where
 8983   8984   
        S: ::tower::Service<
 8984         -
                ::http::Request<Body>,
 8985         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        8985  +
                ::http_1x::Request<Body>,
        8986  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 8986   8987   
                Error = ::std::convert::Infallible,
 8987   8988   
            > + Clone
 8988   8989   
            + Send
 8989   8990   
            + 'static,
 8990   8991   
        S::Future: Send + 'static,
 8991   8992   
    {
 8992   8993   
        self.malformed_string = Some(::aws_smithy_http_server::routing::Route::new(svc));
 8993   8994   
        self
 8994   8995   
    }
 8995   8996
@@ -9018,9019 +9079,9080 @@
 9038   9039   
                            <
 9039   9040   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9040   9041   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9041   9042   
                                    RestJson<L>,
 9042   9043   
                                    crate::operation_shape::MalformedTimestampBodyDateTime,
 9043   9044   
                                    ModelPl::Output
 9044   9045   
                                >
 9045   9046   
                            >::Output
 9046   9047   
                        >,
 9047   9048   
 9048         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9049         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9049  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9050  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9050   9051   
 9051   9052   
                    {
 9052   9053   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9053   9054   
        use ::aws_smithy_http_server::plugin::Plugin;
 9054   9055   
        let svc = crate::operation_shape::MalformedTimestampBodyDateTime::from_handler(handler);
 9055   9056   
        let svc = self.model_plugin.apply(svc);
 9056   9057   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9057   9058   
            .apply(svc);
 9058   9059   
        let svc = self.http_plugin.apply(svc);
 9059   9060   
        self.malformed_timestamp_body_date_time_custom(svc)
@@ -9085,9086 +9165,9166 @@
 9105   9106   
                            <
 9106   9107   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9107   9108   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9108   9109   
                                    RestJson<L>,
 9109   9110   
                                    crate::operation_shape::MalformedTimestampBodyDateTime,
 9110   9111   
                                    ModelPl::Output
 9111   9112   
                                >
 9112   9113   
                            >::Output
 9113   9114   
                        >,
 9114   9115   
 9115         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9116         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9116  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9117  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9117   9118   
 9118   9119   
                    {
 9119   9120   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9120   9121   
        use ::aws_smithy_http_server::plugin::Plugin;
 9121   9122   
        let svc = crate::operation_shape::MalformedTimestampBodyDateTime::from_service(service);
 9122   9123   
        let svc = self.model_plugin.apply(svc);
 9123   9124   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9124   9125   
            .apply(svc);
 9125   9126   
        let svc = self.http_plugin.apply(svc);
 9126   9127   
        self.malformed_timestamp_body_date_time_custom(svc)
 9127   9128   
    }
 9128   9129   
 9129   9130   
    /// Sets the [`MalformedTimestampBodyDateTime`](crate::operation_shape::MalformedTimestampBodyDateTime) to a custom [`Service`](tower::Service).
 9130   9131   
    /// not constrained by the Smithy contract.
 9131   9132   
    fn malformed_timestamp_body_date_time_custom<S>(mut self, svc: S) -> Self
 9132   9133   
    where
 9133   9134   
        S: ::tower::Service<
 9134         -
                ::http::Request<Body>,
 9135         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        9135  +
                ::http_1x::Request<Body>,
        9136  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 9136   9137   
                Error = ::std::convert::Infallible,
 9137   9138   
            > + Clone
 9138   9139   
            + Send
 9139   9140   
            + 'static,
 9140   9141   
        S::Future: Send + 'static,
 9141   9142   
    {
 9142   9143   
        self.malformed_timestamp_body_date_time =
 9143   9144   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 9144   9145   
        self
 9145   9146   
    }
@@ -9169,9170 +9230,9231 @@
 9189   9190   
                            <
 9190   9191   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9191   9192   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9192   9193   
                                    RestJson<L>,
 9193   9194   
                                    crate::operation_shape::MalformedTimestampBodyDefault,
 9194   9195   
                                    ModelPl::Output
 9195   9196   
                                >
 9196   9197   
                            >::Output
 9197   9198   
                        >,
 9198   9199   
 9199         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9200         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9200  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9201  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9201   9202   
 9202   9203   
                    {
 9203   9204   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9204   9205   
        use ::aws_smithy_http_server::plugin::Plugin;
 9205   9206   
        let svc = crate::operation_shape::MalformedTimestampBodyDefault::from_handler(handler);
 9206   9207   
        let svc = self.model_plugin.apply(svc);
 9207   9208   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9208   9209   
            .apply(svc);
 9209   9210   
        let svc = self.http_plugin.apply(svc);
 9210   9211   
        self.malformed_timestamp_body_default_custom(svc)
@@ -9236,9237 +9316,9317 @@
 9256   9257   
                            <
 9257   9258   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9258   9259   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9259   9260   
                                    RestJson<L>,
 9260   9261   
                                    crate::operation_shape::MalformedTimestampBodyDefault,
 9261   9262   
                                    ModelPl::Output
 9262   9263   
                                >
 9263   9264   
                            >::Output
 9264   9265   
                        >,
 9265   9266   
 9266         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9267         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9267  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9268  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9268   9269   
 9269   9270   
                    {
 9270   9271   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9271   9272   
        use ::aws_smithy_http_server::plugin::Plugin;
 9272   9273   
        let svc = crate::operation_shape::MalformedTimestampBodyDefault::from_service(service);
 9273   9274   
        let svc = self.model_plugin.apply(svc);
 9274   9275   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9275   9276   
            .apply(svc);
 9276   9277   
        let svc = self.http_plugin.apply(svc);
 9277   9278   
        self.malformed_timestamp_body_default_custom(svc)
 9278   9279   
    }
 9279   9280   
 9280   9281   
    /// Sets the [`MalformedTimestampBodyDefault`](crate::operation_shape::MalformedTimestampBodyDefault) to a custom [`Service`](tower::Service).
 9281   9282   
    /// not constrained by the Smithy contract.
 9282   9283   
    fn malformed_timestamp_body_default_custom<S>(mut self, svc: S) -> Self
 9283   9284   
    where
 9284   9285   
        S: ::tower::Service<
 9285         -
                ::http::Request<Body>,
 9286         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        9286  +
                ::http_1x::Request<Body>,
        9287  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 9287   9288   
                Error = ::std::convert::Infallible,
 9288   9289   
            > + Clone
 9289   9290   
            + Send
 9290   9291   
            + 'static,
 9291   9292   
        S::Future: Send + 'static,
 9292   9293   
    {
 9293   9294   
        self.malformed_timestamp_body_default =
 9294   9295   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 9295   9296   
        self
 9296   9297   
    }
@@ -9320,9321 +9381,9382 @@
 9340   9341   
                            <
 9341   9342   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9342   9343   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9343   9344   
                                    RestJson<L>,
 9344   9345   
                                    crate::operation_shape::MalformedTimestampBodyHttpDate,
 9345   9346   
                                    ModelPl::Output
 9346   9347   
                                >
 9347   9348   
                            >::Output
 9348   9349   
                        >,
 9349   9350   
 9350         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9351         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9351  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9352  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9352   9353   
 9353   9354   
                    {
 9354   9355   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9355   9356   
        use ::aws_smithy_http_server::plugin::Plugin;
 9356   9357   
        let svc = crate::operation_shape::MalformedTimestampBodyHttpDate::from_handler(handler);
 9357   9358   
        let svc = self.model_plugin.apply(svc);
 9358   9359   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9359   9360   
            .apply(svc);
 9360   9361   
        let svc = self.http_plugin.apply(svc);
 9361   9362   
        self.malformed_timestamp_body_http_date_custom(svc)
@@ -9387,9388 +9467,9468 @@
 9407   9408   
                            <
 9408   9409   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9409   9410   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9410   9411   
                                    RestJson<L>,
 9411   9412   
                                    crate::operation_shape::MalformedTimestampBodyHttpDate,
 9412   9413   
                                    ModelPl::Output
 9413   9414   
                                >
 9414   9415   
                            >::Output
 9415   9416   
                        >,
 9416   9417   
 9417         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9418         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9418  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9419  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9419   9420   
 9420   9421   
                    {
 9421   9422   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9422   9423   
        use ::aws_smithy_http_server::plugin::Plugin;
 9423   9424   
        let svc = crate::operation_shape::MalformedTimestampBodyHttpDate::from_service(service);
 9424   9425   
        let svc = self.model_plugin.apply(svc);
 9425   9426   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9426   9427   
            .apply(svc);
 9427   9428   
        let svc = self.http_plugin.apply(svc);
 9428   9429   
        self.malformed_timestamp_body_http_date_custom(svc)
 9429   9430   
    }
 9430   9431   
 9431   9432   
    /// Sets the [`MalformedTimestampBodyHttpDate`](crate::operation_shape::MalformedTimestampBodyHttpDate) to a custom [`Service`](tower::Service).
 9432   9433   
    /// not constrained by the Smithy contract.
 9433   9434   
    fn malformed_timestamp_body_http_date_custom<S>(mut self, svc: S) -> Self
 9434   9435   
    where
 9435   9436   
        S: ::tower::Service<
 9436         -
                ::http::Request<Body>,
 9437         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        9437  +
                ::http_1x::Request<Body>,
        9438  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 9438   9439   
                Error = ::std::convert::Infallible,
 9439   9440   
            > + Clone
 9440   9441   
            + Send
 9441   9442   
            + 'static,
 9442   9443   
        S::Future: Send + 'static,
 9443   9444   
    {
 9444   9445   
        self.malformed_timestamp_body_http_date =
 9445   9446   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 9446   9447   
        self
 9447   9448   
    }
@@ -9471,9472 +9532,9533 @@
 9491   9492   
                            <
 9492   9493   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9493   9494   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9494   9495   
                                    RestJson<L>,
 9495   9496   
                                    crate::operation_shape::MalformedTimestampHeaderDateTime,
 9496   9497   
                                    ModelPl::Output
 9497   9498   
                                >
 9498   9499   
                            >::Output
 9499   9500   
                        >,
 9500   9501   
 9501         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9502         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9502  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9503  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9503   9504   
 9504   9505   
                    {
 9505   9506   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9506   9507   
        use ::aws_smithy_http_server::plugin::Plugin;
 9507   9508   
        let svc = crate::operation_shape::MalformedTimestampHeaderDateTime::from_handler(handler);
 9508   9509   
        let svc = self.model_plugin.apply(svc);
 9509   9510   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9510   9511   
            .apply(svc);
 9511   9512   
        let svc = self.http_plugin.apply(svc);
 9512   9513   
        self.malformed_timestamp_header_date_time_custom(svc)
@@ -9538,9539 +9618,9619 @@
 9558   9559   
                            <
 9559   9560   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9560   9561   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9561   9562   
                                    RestJson<L>,
 9562   9563   
                                    crate::operation_shape::MalformedTimestampHeaderDateTime,
 9563   9564   
                                    ModelPl::Output
 9564   9565   
                                >
 9565   9566   
                            >::Output
 9566   9567   
                        >,
 9567   9568   
 9568         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9569         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9569  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9570  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9570   9571   
 9571   9572   
                    {
 9572   9573   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9573   9574   
        use ::aws_smithy_http_server::plugin::Plugin;
 9574   9575   
        let svc = crate::operation_shape::MalformedTimestampHeaderDateTime::from_service(service);
 9575   9576   
        let svc = self.model_plugin.apply(svc);
 9576   9577   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9577   9578   
            .apply(svc);
 9578   9579   
        let svc = self.http_plugin.apply(svc);
 9579   9580   
        self.malformed_timestamp_header_date_time_custom(svc)
 9580   9581   
    }
 9581   9582   
 9582   9583   
    /// Sets the [`MalformedTimestampHeaderDateTime`](crate::operation_shape::MalformedTimestampHeaderDateTime) to a custom [`Service`](tower::Service).
 9583   9584   
    /// not constrained by the Smithy contract.
 9584   9585   
    fn malformed_timestamp_header_date_time_custom<S>(mut self, svc: S) -> Self
 9585   9586   
    where
 9586   9587   
        S: ::tower::Service<
 9587         -
                ::http::Request<Body>,
 9588         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        9588  +
                ::http_1x::Request<Body>,
        9589  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 9589   9590   
                Error = ::std::convert::Infallible,
 9590   9591   
            > + Clone
 9591   9592   
            + Send
 9592   9593   
            + 'static,
 9593   9594   
        S::Future: Send + 'static,
 9594   9595   
    {
 9595   9596   
        self.malformed_timestamp_header_date_time =
 9596   9597   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 9597   9598   
        self
 9598   9599   
    }
@@ -9622,9623 +9683,9684 @@
 9642   9643   
                            <
 9643   9644   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9644   9645   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9645   9646   
                                    RestJson<L>,
 9646   9647   
                                    crate::operation_shape::MalformedTimestampHeaderDefault,
 9647   9648   
                                    ModelPl::Output
 9648   9649   
                                >
 9649   9650   
                            >::Output
 9650   9651   
                        >,
 9651   9652   
 9652         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9653         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9653  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9654  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9654   9655   
 9655   9656   
                    {
 9656   9657   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9657   9658   
        use ::aws_smithy_http_server::plugin::Plugin;
 9658   9659   
        let svc = crate::operation_shape::MalformedTimestampHeaderDefault::from_handler(handler);
 9659   9660   
        let svc = self.model_plugin.apply(svc);
 9660   9661   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9661   9662   
            .apply(svc);
 9662   9663   
        let svc = self.http_plugin.apply(svc);
 9663   9664   
        self.malformed_timestamp_header_default_custom(svc)
@@ -9689,9690 +9769,9770 @@
 9709   9710   
                            <
 9710   9711   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9711   9712   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9712   9713   
                                    RestJson<L>,
 9713   9714   
                                    crate::operation_shape::MalformedTimestampHeaderDefault,
 9714   9715   
                                    ModelPl::Output
 9715   9716   
                                >
 9716   9717   
                            >::Output
 9717   9718   
                        >,
 9718   9719   
 9719         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9720         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9720  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9721  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9721   9722   
 9722   9723   
                    {
 9723   9724   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9724   9725   
        use ::aws_smithy_http_server::plugin::Plugin;
 9725   9726   
        let svc = crate::operation_shape::MalformedTimestampHeaderDefault::from_service(service);
 9726   9727   
        let svc = self.model_plugin.apply(svc);
 9727   9728   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9728   9729   
            .apply(svc);
 9729   9730   
        let svc = self.http_plugin.apply(svc);
 9730   9731   
        self.malformed_timestamp_header_default_custom(svc)
 9731   9732   
    }
 9732   9733   
 9733   9734   
    /// Sets the [`MalformedTimestampHeaderDefault`](crate::operation_shape::MalformedTimestampHeaderDefault) to a custom [`Service`](tower::Service).
 9734   9735   
    /// not constrained by the Smithy contract.
 9735   9736   
    fn malformed_timestamp_header_default_custom<S>(mut self, svc: S) -> Self
 9736   9737   
    where
 9737   9738   
        S: ::tower::Service<
 9738         -
                ::http::Request<Body>,
 9739         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        9739  +
                ::http_1x::Request<Body>,
        9740  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 9740   9741   
                Error = ::std::convert::Infallible,
 9741   9742   
            > + Clone
 9742   9743   
            + Send
 9743   9744   
            + 'static,
 9744   9745   
        S::Future: Send + 'static,
 9745   9746   
    {
 9746   9747   
        self.malformed_timestamp_header_default =
 9747   9748   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 9748   9749   
        self
 9749   9750   
    }
@@ -9773,9774 +9834,9835 @@
 9793   9794   
                            <
 9794   9795   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9795   9796   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9796   9797   
                                    RestJson<L>,
 9797   9798   
                                    crate::operation_shape::MalformedTimestampHeaderEpoch,
 9798   9799   
                                    ModelPl::Output
 9799   9800   
                                >
 9800   9801   
                            >::Output
 9801   9802   
                        >,
 9802   9803   
 9803         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9804         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9804  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9805  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9805   9806   
 9806   9807   
                    {
 9807   9808   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9808   9809   
        use ::aws_smithy_http_server::plugin::Plugin;
 9809   9810   
        let svc = crate::operation_shape::MalformedTimestampHeaderEpoch::from_handler(handler);
 9810   9811   
        let svc = self.model_plugin.apply(svc);
 9811   9812   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9812   9813   
            .apply(svc);
 9813   9814   
        let svc = self.http_plugin.apply(svc);
 9814   9815   
        self.malformed_timestamp_header_epoch_custom(svc)
@@ -9840,9841 +9920,9921 @@
 9860   9861   
                            <
 9861   9862   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9862   9863   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9863   9864   
                                    RestJson<L>,
 9864   9865   
                                    crate::operation_shape::MalformedTimestampHeaderEpoch,
 9865   9866   
                                    ModelPl::Output
 9866   9867   
                                >
 9867   9868   
                            >::Output
 9868   9869   
                        >,
 9869   9870   
 9870         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9871         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9871  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9872  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9872   9873   
 9873   9874   
                    {
 9874   9875   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9875   9876   
        use ::aws_smithy_http_server::plugin::Plugin;
 9876   9877   
        let svc = crate::operation_shape::MalformedTimestampHeaderEpoch::from_service(service);
 9877   9878   
        let svc = self.model_plugin.apply(svc);
 9878   9879   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9879   9880   
            .apply(svc);
 9880   9881   
        let svc = self.http_plugin.apply(svc);
 9881   9882   
        self.malformed_timestamp_header_epoch_custom(svc)
 9882   9883   
    }
 9883   9884   
 9884   9885   
    /// Sets the [`MalformedTimestampHeaderEpoch`](crate::operation_shape::MalformedTimestampHeaderEpoch) to a custom [`Service`](tower::Service).
 9885   9886   
    /// not constrained by the Smithy contract.
 9886   9887   
    fn malformed_timestamp_header_epoch_custom<S>(mut self, svc: S) -> Self
 9887   9888   
    where
 9888   9889   
        S: ::tower::Service<
 9889         -
                ::http::Request<Body>,
 9890         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
        9890  +
                ::http_1x::Request<Body>,
        9891  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
 9891   9892   
                Error = ::std::convert::Infallible,
 9892   9893   
            > + Clone
 9893   9894   
            + Send
 9894   9895   
            + 'static,
 9895   9896   
        S::Future: Send + 'static,
 9896   9897   
    {
 9897   9898   
        self.malformed_timestamp_header_epoch =
 9898   9899   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
 9899   9900   
        self
 9900   9901   
    }
@@ -9924,9925 +9985,9986 @@
 9944   9945   
                            <
 9945   9946   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
 9946   9947   
                                as ::aws_smithy_http_server::plugin::Plugin<
 9947   9948   
                                    RestJson<L>,
 9948   9949   
                                    crate::operation_shape::MalformedTimestampPathDefault,
 9949   9950   
                                    ModelPl::Output
 9950   9951   
                                >
 9951   9952   
                            >::Output
 9952   9953   
                        >,
 9953   9954   
 9954         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
 9955         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
        9955  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
        9956  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
 9956   9957   
 9957   9958   
                    {
 9958   9959   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
 9959   9960   
        use ::aws_smithy_http_server::plugin::Plugin;
 9960   9961   
        let svc = crate::operation_shape::MalformedTimestampPathDefault::from_handler(handler);
 9961   9962   
        let svc = self.model_plugin.apply(svc);
 9962   9963   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
 9963   9964   
            .apply(svc);
 9964   9965   
        let svc = self.http_plugin.apply(svc);
 9965   9966   
        self.malformed_timestamp_path_default_custom(svc)
@@ -9991,9992 +10071,10072 @@
10011  10012   
                            <
10012  10013   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10013  10014   
                                as ::aws_smithy_http_server::plugin::Plugin<
10014  10015   
                                    RestJson<L>,
10015  10016   
                                    crate::operation_shape::MalformedTimestampPathDefault,
10016  10017   
                                    ModelPl::Output
10017  10018   
                                >
10018  10019   
                            >::Output
10019  10020   
                        >,
10020  10021   
10021         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10022         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10022  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10023  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10023  10024   
10024  10025   
                    {
10025  10026   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10026  10027   
        use ::aws_smithy_http_server::plugin::Plugin;
10027  10028   
        let svc = crate::operation_shape::MalformedTimestampPathDefault::from_service(service);
10028  10029   
        let svc = self.model_plugin.apply(svc);
10029  10030   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10030  10031   
            .apply(svc);
10031  10032   
        let svc = self.http_plugin.apply(svc);
10032  10033   
        self.malformed_timestamp_path_default_custom(svc)
10033  10034   
    }
10034  10035   
10035  10036   
    /// Sets the [`MalformedTimestampPathDefault`](crate::operation_shape::MalformedTimestampPathDefault) to a custom [`Service`](tower::Service).
10036  10037   
    /// not constrained by the Smithy contract.
10037  10038   
    fn malformed_timestamp_path_default_custom<S>(mut self, svc: S) -> Self
10038  10039   
    where
10039  10040   
        S: ::tower::Service<
10040         -
                ::http::Request<Body>,
10041         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10041  +
                ::http_1x::Request<Body>,
       10042  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10042  10043   
                Error = ::std::convert::Infallible,
10043  10044   
            > + Clone
10044  10045   
            + Send
10045  10046   
            + 'static,
10046  10047   
        S::Future: Send + 'static,
10047  10048   
    {
10048  10049   
        self.malformed_timestamp_path_default =
10049  10050   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
10050  10051   
        self
10051  10052   
    }
@@ -10075,10076 +10136,10137 @@
10095  10096   
                            <
10096  10097   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10097  10098   
                                as ::aws_smithy_http_server::plugin::Plugin<
10098  10099   
                                    RestJson<L>,
10099  10100   
                                    crate::operation_shape::MalformedTimestampPathEpoch,
10100  10101   
                                    ModelPl::Output
10101  10102   
                                >
10102  10103   
                            >::Output
10103  10104   
                        >,
10104  10105   
10105         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10106         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10106  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10107  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10107  10108   
10108  10109   
                    {
10109  10110   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10110  10111   
        use ::aws_smithy_http_server::plugin::Plugin;
10111  10112   
        let svc = crate::operation_shape::MalformedTimestampPathEpoch::from_handler(handler);
10112  10113   
        let svc = self.model_plugin.apply(svc);
10113  10114   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10114  10115   
            .apply(svc);
10115  10116   
        let svc = self.http_plugin.apply(svc);
10116  10117   
        self.malformed_timestamp_path_epoch_custom(svc)
@@ -10142,10143 +10222,10223 @@
10162  10163   
                            <
10163  10164   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10164  10165   
                                as ::aws_smithy_http_server::plugin::Plugin<
10165  10166   
                                    RestJson<L>,
10166  10167   
                                    crate::operation_shape::MalformedTimestampPathEpoch,
10167  10168   
                                    ModelPl::Output
10168  10169   
                                >
10169  10170   
                            >::Output
10170  10171   
                        >,
10171  10172   
10172         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10173         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10173  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10174  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10174  10175   
10175  10176   
                    {
10176  10177   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10177  10178   
        use ::aws_smithy_http_server::plugin::Plugin;
10178  10179   
        let svc = crate::operation_shape::MalformedTimestampPathEpoch::from_service(service);
10179  10180   
        let svc = self.model_plugin.apply(svc);
10180  10181   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10181  10182   
            .apply(svc);
10182  10183   
        let svc = self.http_plugin.apply(svc);
10183  10184   
        self.malformed_timestamp_path_epoch_custom(svc)
10184  10185   
    }
10185  10186   
10186  10187   
    /// Sets the [`MalformedTimestampPathEpoch`](crate::operation_shape::MalformedTimestampPathEpoch) to a custom [`Service`](tower::Service).
10187  10188   
    /// not constrained by the Smithy contract.
10188  10189   
    fn malformed_timestamp_path_epoch_custom<S>(mut self, svc: S) -> Self
10189  10190   
    where
10190  10191   
        S: ::tower::Service<
10191         -
                ::http::Request<Body>,
10192         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10192  +
                ::http_1x::Request<Body>,
       10193  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10193  10194   
                Error = ::std::convert::Infallible,
10194  10195   
            > + Clone
10195  10196   
            + Send
10196  10197   
            + 'static,
10197  10198   
        S::Future: Send + 'static,
10198  10199   
    {
10199  10200   
        self.malformed_timestamp_path_epoch =
10200  10201   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
10201  10202   
        self
10202  10203   
    }
@@ -10226,10227 +10287,10288 @@
10246  10247   
                            <
10247  10248   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10248  10249   
                                as ::aws_smithy_http_server::plugin::Plugin<
10249  10250   
                                    RestJson<L>,
10250  10251   
                                    crate::operation_shape::MalformedTimestampPathHttpDate,
10251  10252   
                                    ModelPl::Output
10252  10253   
                                >
10253  10254   
                            >::Output
10254  10255   
                        >,
10255  10256   
10256         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10257         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10257  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10258  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10258  10259   
10259  10260   
                    {
10260  10261   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10261  10262   
        use ::aws_smithy_http_server::plugin::Plugin;
10262  10263   
        let svc = crate::operation_shape::MalformedTimestampPathHttpDate::from_handler(handler);
10263  10264   
        let svc = self.model_plugin.apply(svc);
10264  10265   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10265  10266   
            .apply(svc);
10266  10267   
        let svc = self.http_plugin.apply(svc);
10267  10268   
        self.malformed_timestamp_path_http_date_custom(svc)
@@ -10293,10294 +10373,10374 @@
10313  10314   
                            <
10314  10315   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10315  10316   
                                as ::aws_smithy_http_server::plugin::Plugin<
10316  10317   
                                    RestJson<L>,
10317  10318   
                                    crate::operation_shape::MalformedTimestampPathHttpDate,
10318  10319   
                                    ModelPl::Output
10319  10320   
                                >
10320  10321   
                            >::Output
10321  10322   
                        >,
10322  10323   
10323         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10324         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10324  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10325  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10325  10326   
10326  10327   
                    {
10327  10328   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10328  10329   
        use ::aws_smithy_http_server::plugin::Plugin;
10329  10330   
        let svc = crate::operation_shape::MalformedTimestampPathHttpDate::from_service(service);
10330  10331   
        let svc = self.model_plugin.apply(svc);
10331  10332   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10332  10333   
            .apply(svc);
10333  10334   
        let svc = self.http_plugin.apply(svc);
10334  10335   
        self.malformed_timestamp_path_http_date_custom(svc)
10335  10336   
    }
10336  10337   
10337  10338   
    /// Sets the [`MalformedTimestampPathHttpDate`](crate::operation_shape::MalformedTimestampPathHttpDate) to a custom [`Service`](tower::Service).
10338  10339   
    /// not constrained by the Smithy contract.
10339  10340   
    fn malformed_timestamp_path_http_date_custom<S>(mut self, svc: S) -> Self
10340  10341   
    where
10341  10342   
        S: ::tower::Service<
10342         -
                ::http::Request<Body>,
10343         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10343  +
                ::http_1x::Request<Body>,
       10344  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10344  10345   
                Error = ::std::convert::Infallible,
10345  10346   
            > + Clone
10346  10347   
            + Send
10347  10348   
            + 'static,
10348  10349   
        S::Future: Send + 'static,
10349  10350   
    {
10350  10351   
        self.malformed_timestamp_path_http_date =
10351  10352   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
10352  10353   
        self
10353  10354   
    }
@@ -10377,10378 +10438,10439 @@
10397  10398   
                            <
10398  10399   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10399  10400   
                                as ::aws_smithy_http_server::plugin::Plugin<
10400  10401   
                                    RestJson<L>,
10401  10402   
                                    crate::operation_shape::MalformedTimestampQueryDefault,
10402  10403   
                                    ModelPl::Output
10403  10404   
                                >
10404  10405   
                            >::Output
10405  10406   
                        >,
10406  10407   
10407         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10408         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10408  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10409  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10409  10410   
10410  10411   
                    {
10411  10412   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10412  10413   
        use ::aws_smithy_http_server::plugin::Plugin;
10413  10414   
        let svc = crate::operation_shape::MalformedTimestampQueryDefault::from_handler(handler);
10414  10415   
        let svc = self.model_plugin.apply(svc);
10415  10416   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10416  10417   
            .apply(svc);
10417  10418   
        let svc = self.http_plugin.apply(svc);
10418  10419   
        self.malformed_timestamp_query_default_custom(svc)
@@ -10444,10445 +10524,10525 @@
10464  10465   
                            <
10465  10466   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10466  10467   
                                as ::aws_smithy_http_server::plugin::Plugin<
10467  10468   
                                    RestJson<L>,
10468  10469   
                                    crate::operation_shape::MalformedTimestampQueryDefault,
10469  10470   
                                    ModelPl::Output
10470  10471   
                                >
10471  10472   
                            >::Output
10472  10473   
                        >,
10473  10474   
10474         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10475         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10475  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10476  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10476  10477   
10477  10478   
                    {
10478  10479   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10479  10480   
        use ::aws_smithy_http_server::plugin::Plugin;
10480  10481   
        let svc = crate::operation_shape::MalformedTimestampQueryDefault::from_service(service);
10481  10482   
        let svc = self.model_plugin.apply(svc);
10482  10483   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10483  10484   
            .apply(svc);
10484  10485   
        let svc = self.http_plugin.apply(svc);
10485  10486   
        self.malformed_timestamp_query_default_custom(svc)
10486  10487   
    }
10487  10488   
10488  10489   
    /// Sets the [`MalformedTimestampQueryDefault`](crate::operation_shape::MalformedTimestampQueryDefault) to a custom [`Service`](tower::Service).
10489  10490   
    /// not constrained by the Smithy contract.
10490  10491   
    fn malformed_timestamp_query_default_custom<S>(mut self, svc: S) -> Self
10491  10492   
    where
10492  10493   
        S: ::tower::Service<
10493         -
                ::http::Request<Body>,
10494         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10494  +
                ::http_1x::Request<Body>,
       10495  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10495  10496   
                Error = ::std::convert::Infallible,
10496  10497   
            > + Clone
10497  10498   
            + Send
10498  10499   
            + 'static,
10499  10500   
        S::Future: Send + 'static,
10500  10501   
    {
10501  10502   
        self.malformed_timestamp_query_default =
10502  10503   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
10503  10504   
        self
10504  10505   
    }
@@ -10528,10529 +10589,10590 @@
10548  10549   
                            <
10549  10550   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10550  10551   
                                as ::aws_smithy_http_server::plugin::Plugin<
10551  10552   
                                    RestJson<L>,
10552  10553   
                                    crate::operation_shape::MalformedTimestampQueryEpoch,
10553  10554   
                                    ModelPl::Output
10554  10555   
                                >
10555  10556   
                            >::Output
10556  10557   
                        >,
10557  10558   
10558         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10559         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10559  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10560  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10560  10561   
10561  10562   
                    {
10562  10563   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10563  10564   
        use ::aws_smithy_http_server::plugin::Plugin;
10564  10565   
        let svc = crate::operation_shape::MalformedTimestampQueryEpoch::from_handler(handler);
10565  10566   
        let svc = self.model_plugin.apply(svc);
10566  10567   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10567  10568   
            .apply(svc);
10568  10569   
        let svc = self.http_plugin.apply(svc);
10569  10570   
        self.malformed_timestamp_query_epoch_custom(svc)
@@ -10595,10596 +10675,10676 @@
10615  10616   
                            <
10616  10617   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10617  10618   
                                as ::aws_smithy_http_server::plugin::Plugin<
10618  10619   
                                    RestJson<L>,
10619  10620   
                                    crate::operation_shape::MalformedTimestampQueryEpoch,
10620  10621   
                                    ModelPl::Output
10621  10622   
                                >
10622  10623   
                            >::Output
10623  10624   
                        >,
10624  10625   
10625         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10626         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10626  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10627  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10627  10628   
10628  10629   
                    {
10629  10630   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10630  10631   
        use ::aws_smithy_http_server::plugin::Plugin;
10631  10632   
        let svc = crate::operation_shape::MalformedTimestampQueryEpoch::from_service(service);
10632  10633   
        let svc = self.model_plugin.apply(svc);
10633  10634   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10634  10635   
            .apply(svc);
10635  10636   
        let svc = self.http_plugin.apply(svc);
10636  10637   
        self.malformed_timestamp_query_epoch_custom(svc)
10637  10638   
    }
10638  10639   
10639  10640   
    /// Sets the [`MalformedTimestampQueryEpoch`](crate::operation_shape::MalformedTimestampQueryEpoch) to a custom [`Service`](tower::Service).
10640  10641   
    /// not constrained by the Smithy contract.
10641  10642   
    fn malformed_timestamp_query_epoch_custom<S>(mut self, svc: S) -> Self
10642  10643   
    where
10643  10644   
        S: ::tower::Service<
10644         -
                ::http::Request<Body>,
10645         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10645  +
                ::http_1x::Request<Body>,
       10646  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10646  10647   
                Error = ::std::convert::Infallible,
10647  10648   
            > + Clone
10648  10649   
            + Send
10649  10650   
            + 'static,
10650  10651   
        S::Future: Send + 'static,
10651  10652   
    {
10652  10653   
        self.malformed_timestamp_query_epoch =
10653  10654   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
10654  10655   
        self
10655  10656   
    }
@@ -10679,10680 +10740,10741 @@
10699  10700   
                            <
10700  10701   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10701  10702   
                                as ::aws_smithy_http_server::plugin::Plugin<
10702  10703   
                                    RestJson<L>,
10703  10704   
                                    crate::operation_shape::MalformedTimestampQueryHttpDate,
10704  10705   
                                    ModelPl::Output
10705  10706   
                                >
10706  10707   
                            >::Output
10707  10708   
                        >,
10708  10709   
10709         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10710         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10710  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10711  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10711  10712   
10712  10713   
                    {
10713  10714   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10714  10715   
        use ::aws_smithy_http_server::plugin::Plugin;
10715  10716   
        let svc = crate::operation_shape::MalformedTimestampQueryHttpDate::from_handler(handler);
10716  10717   
        let svc = self.model_plugin.apply(svc);
10717  10718   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10718  10719   
            .apply(svc);
10719  10720   
        let svc = self.http_plugin.apply(svc);
10720  10721   
        self.malformed_timestamp_query_http_date_custom(svc)
@@ -10746,10747 +10826,10827 @@
10766  10767   
                            <
10767  10768   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10768  10769   
                                as ::aws_smithy_http_server::plugin::Plugin<
10769  10770   
                                    RestJson<L>,
10770  10771   
                                    crate::operation_shape::MalformedTimestampQueryHttpDate,
10771  10772   
                                    ModelPl::Output
10772  10773   
                                >
10773  10774   
                            >::Output
10774  10775   
                        >,
10775  10776   
10776         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10777         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10777  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10778  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10778  10779   
10779  10780   
                    {
10780  10781   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10781  10782   
        use ::aws_smithy_http_server::plugin::Plugin;
10782  10783   
        let svc = crate::operation_shape::MalformedTimestampQueryHttpDate::from_service(service);
10783  10784   
        let svc = self.model_plugin.apply(svc);
10784  10785   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10785  10786   
            .apply(svc);
10786  10787   
        let svc = self.http_plugin.apply(svc);
10787  10788   
        self.malformed_timestamp_query_http_date_custom(svc)
10788  10789   
    }
10789  10790   
10790  10791   
    /// Sets the [`MalformedTimestampQueryHttpDate`](crate::operation_shape::MalformedTimestampQueryHttpDate) to a custom [`Service`](tower::Service).
10791  10792   
    /// not constrained by the Smithy contract.
10792  10793   
    fn malformed_timestamp_query_http_date_custom<S>(mut self, svc: S) -> Self
10793  10794   
    where
10794  10795   
        S: ::tower::Service<
10795         -
                ::http::Request<Body>,
10796         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10796  +
                ::http_1x::Request<Body>,
       10797  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10797  10798   
                Error = ::std::convert::Infallible,
10798  10799   
            > + Clone
10799  10800   
            + Send
10800  10801   
            + 'static,
10801  10802   
        S::Future: Send + 'static,
10802  10803   
    {
10803  10804   
        self.malformed_timestamp_query_http_date =
10804  10805   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
10805  10806   
        self
10806  10807   
    }
@@ -10830,10831 +10891,10892 @@
10850  10851   
                            <
10851  10852   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10852  10853   
                                as ::aws_smithy_http_server::plugin::Plugin<
10853  10854   
                                    RestJson<L>,
10854  10855   
                                    crate::operation_shape::MalformedUnion,
10855  10856   
                                    ModelPl::Output
10856  10857   
                                >
10857  10858   
                            >::Output
10858  10859   
                        >,
10859  10860   
10860         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10861         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10861  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10862  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10862  10863   
10863  10864   
                    {
10864  10865   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10865  10866   
        use ::aws_smithy_http_server::plugin::Plugin;
10866  10867   
        let svc = crate::operation_shape::MalformedUnion::from_handler(handler);
10867  10868   
        let svc = self.model_plugin.apply(svc);
10868  10869   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10869  10870   
            .apply(svc);
10870  10871   
        let svc = self.http_plugin.apply(svc);
10871  10872   
        self.malformed_union_custom(svc)
@@ -10897,10898 +10977,10978 @@
10917  10918   
                            <
10918  10919   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
10919  10920   
                                as ::aws_smithy_http_server::plugin::Plugin<
10920  10921   
                                    RestJson<L>,
10921  10922   
                                    crate::operation_shape::MalformedUnion,
10922  10923   
                                    ModelPl::Output
10923  10924   
                                >
10924  10925   
                            >::Output
10925  10926   
                        >,
10926  10927   
10927         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
10928         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       10928  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       10929  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
10929  10930   
10930  10931   
                    {
10931  10932   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
10932  10933   
        use ::aws_smithy_http_server::plugin::Plugin;
10933  10934   
        let svc = crate::operation_shape::MalformedUnion::from_service(service);
10934  10935   
        let svc = self.model_plugin.apply(svc);
10935  10936   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
10936  10937   
            .apply(svc);
10937  10938   
        let svc = self.http_plugin.apply(svc);
10938  10939   
        self.malformed_union_custom(svc)
10939  10940   
    }
10940  10941   
10941  10942   
    /// Sets the [`MalformedUnion`](crate::operation_shape::MalformedUnion) to a custom [`Service`](tower::Service).
10942  10943   
    /// not constrained by the Smithy contract.
10943  10944   
    fn malformed_union_custom<S>(mut self, svc: S) -> Self
10944  10945   
    where
10945  10946   
        S: ::tower::Service<
10946         -
                ::http::Request<Body>,
10947         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       10947  +
                ::http_1x::Request<Body>,
       10948  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
10948  10949   
                Error = ::std::convert::Infallible,
10949  10950   
            > + Clone
10950  10951   
            + Send
10951  10952   
            + 'static,
10952  10953   
        S::Future: Send + 'static,
10953  10954   
    {
10954  10955   
        self.malformed_union = Some(::aws_smithy_http_server::routing::Route::new(svc));
10955  10956   
        self
10956  10957   
    }
10957  10958
@@ -10980,10981 +11041,11042 @@
11000  11001   
                            <
11001  11002   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11002  11003   
                                as ::aws_smithy_http_server::plugin::Plugin<
11003  11004   
                                    RestJson<L>,
11004  11005   
                                    crate::operation_shape::MediaTypeHeader,
11005  11006   
                                    ModelPl::Output
11006  11007   
                                >
11007  11008   
                            >::Output
11008  11009   
                        >,
11009  11010   
11010         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11011         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11011  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11012  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11012  11013   
11013  11014   
                    {
11014  11015   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11015  11016   
        use ::aws_smithy_http_server::plugin::Plugin;
11016  11017   
        let svc = crate::operation_shape::MediaTypeHeader::from_handler(handler);
11017  11018   
        let svc = self.model_plugin.apply(svc);
11018  11019   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11019  11020   
            .apply(svc);
11020  11021   
        let svc = self.http_plugin.apply(svc);
11021  11022   
        self.media_type_header_custom(svc)
@@ -11047,11048 +11127,11128 @@
11067  11068   
                            <
11068  11069   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11069  11070   
                                as ::aws_smithy_http_server::plugin::Plugin<
11070  11071   
                                    RestJson<L>,
11071  11072   
                                    crate::operation_shape::MediaTypeHeader,
11072  11073   
                                    ModelPl::Output
11073  11074   
                                >
11074  11075   
                            >::Output
11075  11076   
                        >,
11076  11077   
11077         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11078         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11078  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11079  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11079  11080   
11080  11081   
                    {
11081  11082   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11082  11083   
        use ::aws_smithy_http_server::plugin::Plugin;
11083  11084   
        let svc = crate::operation_shape::MediaTypeHeader::from_service(service);
11084  11085   
        let svc = self.model_plugin.apply(svc);
11085  11086   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11086  11087   
            .apply(svc);
11087  11088   
        let svc = self.http_plugin.apply(svc);
11088  11089   
        self.media_type_header_custom(svc)
11089  11090   
    }
11090  11091   
11091  11092   
    /// Sets the [`MediaTypeHeader`](crate::operation_shape::MediaTypeHeader) to a custom [`Service`](tower::Service).
11092  11093   
    /// not constrained by the Smithy contract.
11093  11094   
    fn media_type_header_custom<S>(mut self, svc: S) -> Self
11094  11095   
    where
11095  11096   
        S: ::tower::Service<
11096         -
                ::http::Request<Body>,
11097         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       11097  +
                ::http_1x::Request<Body>,
       11098  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
11098  11099   
                Error = ::std::convert::Infallible,
11099  11100   
            > + Clone
11100  11101   
            + Send
11101  11102   
            + 'static,
11102  11103   
        S::Future: Send + 'static,
11103  11104   
    {
11104  11105   
        self.media_type_header = Some(::aws_smithy_http_server::routing::Route::new(svc));
11105  11106   
        self
11106  11107   
    }
11107  11108
@@ -11130,11131 +11191,11192 @@
11150  11151   
                            <
11151  11152   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11152  11153   
                                as ::aws_smithy_http_server::plugin::Plugin<
11153  11154   
                                    RestJson<L>,
11154  11155   
                                    crate::operation_shape::NoInputAndNoOutput,
11155  11156   
                                    ModelPl::Output
11156  11157   
                                >
11157  11158   
                            >::Output
11158  11159   
                        >,
11159  11160   
11160         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11161         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11161  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11162  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11162  11163   
11163  11164   
                    {
11164  11165   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11165  11166   
        use ::aws_smithy_http_server::plugin::Plugin;
11166  11167   
        let svc = crate::operation_shape::NoInputAndNoOutput::from_handler(handler);
11167  11168   
        let svc = self.model_plugin.apply(svc);
11168  11169   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11169  11170   
            .apply(svc);
11170  11171   
        let svc = self.http_plugin.apply(svc);
11171  11172   
        self.no_input_and_no_output_custom(svc)
@@ -11197,11198 +11277,11278 @@
11217  11218   
                            <
11218  11219   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11219  11220   
                                as ::aws_smithy_http_server::plugin::Plugin<
11220  11221   
                                    RestJson<L>,
11221  11222   
                                    crate::operation_shape::NoInputAndNoOutput,
11222  11223   
                                    ModelPl::Output
11223  11224   
                                >
11224  11225   
                            >::Output
11225  11226   
                        >,
11226  11227   
11227         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11228         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11228  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11229  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11229  11230   
11230  11231   
                    {
11231  11232   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11232  11233   
        use ::aws_smithy_http_server::plugin::Plugin;
11233  11234   
        let svc = crate::operation_shape::NoInputAndNoOutput::from_service(service);
11234  11235   
        let svc = self.model_plugin.apply(svc);
11235  11236   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11236  11237   
            .apply(svc);
11237  11238   
        let svc = self.http_plugin.apply(svc);
11238  11239   
        self.no_input_and_no_output_custom(svc)
11239  11240   
    }
11240  11241   
11241  11242   
    /// Sets the [`NoInputAndNoOutput`](crate::operation_shape::NoInputAndNoOutput) to a custom [`Service`](tower::Service).
11242  11243   
    /// not constrained by the Smithy contract.
11243  11244   
    fn no_input_and_no_output_custom<S>(mut self, svc: S) -> Self
11244  11245   
    where
11245  11246   
        S: ::tower::Service<
11246         -
                ::http::Request<Body>,
11247         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       11247  +
                ::http_1x::Request<Body>,
       11248  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
11248  11249   
                Error = ::std::convert::Infallible,
11249  11250   
            > + Clone
11250  11251   
            + Send
11251  11252   
            + 'static,
11252  11253   
        S::Future: Send + 'static,
11253  11254   
    {
11254  11255   
        self.no_input_and_no_output = Some(::aws_smithy_http_server::routing::Route::new(svc));
11255  11256   
        self
11256  11257   
    }
11257  11258
@@ -11280,11281 +11341,11342 @@
11300  11301   
                            <
11301  11302   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11302  11303   
                                as ::aws_smithy_http_server::plugin::Plugin<
11303  11304   
                                    RestJson<L>,
11304  11305   
                                    crate::operation_shape::NoInputAndOutput,
11305  11306   
                                    ModelPl::Output
11306  11307   
                                >
11307  11308   
                            >::Output
11308  11309   
                        >,
11309  11310   
11310         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11311         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11311  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11312  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11312  11313   
11313  11314   
                    {
11314  11315   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11315  11316   
        use ::aws_smithy_http_server::plugin::Plugin;
11316  11317   
        let svc = crate::operation_shape::NoInputAndOutput::from_handler(handler);
11317  11318   
        let svc = self.model_plugin.apply(svc);
11318  11319   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11319  11320   
            .apply(svc);
11320  11321   
        let svc = self.http_plugin.apply(svc);
11321  11322   
        self.no_input_and_output_custom(svc)
@@ -11347,11348 +11427,11428 @@
11367  11368   
                            <
11368  11369   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11369  11370   
                                as ::aws_smithy_http_server::plugin::Plugin<
11370  11371   
                                    RestJson<L>,
11371  11372   
                                    crate::operation_shape::NoInputAndOutput,
11372  11373   
                                    ModelPl::Output
11373  11374   
                                >
11374  11375   
                            >::Output
11375  11376   
                        >,
11376  11377   
11377         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11378         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11378  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11379  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11379  11380   
11380  11381   
                    {
11381  11382   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11382  11383   
        use ::aws_smithy_http_server::plugin::Plugin;
11383  11384   
        let svc = crate::operation_shape::NoInputAndOutput::from_service(service);
11384  11385   
        let svc = self.model_plugin.apply(svc);
11385  11386   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11386  11387   
            .apply(svc);
11387  11388   
        let svc = self.http_plugin.apply(svc);
11388  11389   
        self.no_input_and_output_custom(svc)
11389  11390   
    }
11390  11391   
11391  11392   
    /// Sets the [`NoInputAndOutput`](crate::operation_shape::NoInputAndOutput) to a custom [`Service`](tower::Service).
11392  11393   
    /// not constrained by the Smithy contract.
11393  11394   
    fn no_input_and_output_custom<S>(mut self, svc: S) -> Self
11394  11395   
    where
11395  11396   
        S: ::tower::Service<
11396         -
                ::http::Request<Body>,
11397         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       11397  +
                ::http_1x::Request<Body>,
       11398  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
11398  11399   
                Error = ::std::convert::Infallible,
11399  11400   
            > + Clone
11400  11401   
            + Send
11401  11402   
            + 'static,
11402  11403   
        S::Future: Send + 'static,
11403  11404   
    {
11404  11405   
        self.no_input_and_output = Some(::aws_smithy_http_server::routing::Route::new(svc));
11405  11406   
        self
11406  11407   
    }
11407  11408
@@ -11430,11431 +11491,11492 @@
11450  11451   
                            <
11451  11452   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11452  11453   
                                as ::aws_smithy_http_server::plugin::Plugin<
11453  11454   
                                    RestJson<L>,
11454  11455   
                                    crate::operation_shape::NullAndEmptyHeadersClient,
11455  11456   
                                    ModelPl::Output
11456  11457   
                                >
11457  11458   
                            >::Output
11458  11459   
                        >,
11459  11460   
11460         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11461         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11461  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11462  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11462  11463   
11463  11464   
                    {
11464  11465   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11465  11466   
        use ::aws_smithy_http_server::plugin::Plugin;
11466  11467   
        let svc = crate::operation_shape::NullAndEmptyHeadersClient::from_handler(handler);
11467  11468   
        let svc = self.model_plugin.apply(svc);
11468  11469   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11469  11470   
            .apply(svc);
11470  11471   
        let svc = self.http_plugin.apply(svc);
11471  11472   
        self.null_and_empty_headers_client_custom(svc)
@@ -11497,11498 +11577,11578 @@
11517  11518   
                            <
11518  11519   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11519  11520   
                                as ::aws_smithy_http_server::plugin::Plugin<
11520  11521   
                                    RestJson<L>,
11521  11522   
                                    crate::operation_shape::NullAndEmptyHeadersClient,
11522  11523   
                                    ModelPl::Output
11523  11524   
                                >
11524  11525   
                            >::Output
11525  11526   
                        >,
11526  11527   
11527         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11528         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11528  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11529  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11529  11530   
11530  11531   
                    {
11531  11532   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11532  11533   
        use ::aws_smithy_http_server::plugin::Plugin;
11533  11534   
        let svc = crate::operation_shape::NullAndEmptyHeadersClient::from_service(service);
11534  11535   
        let svc = self.model_plugin.apply(svc);
11535  11536   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11536  11537   
            .apply(svc);
11537  11538   
        let svc = self.http_plugin.apply(svc);
11538  11539   
        self.null_and_empty_headers_client_custom(svc)
11539  11540   
    }
11540  11541   
11541  11542   
    /// Sets the [`NullAndEmptyHeadersClient`](crate::operation_shape::NullAndEmptyHeadersClient) to a custom [`Service`](tower::Service).
11542  11543   
    /// not constrained by the Smithy contract.
11543  11544   
    fn null_and_empty_headers_client_custom<S>(mut self, svc: S) -> Self
11544  11545   
    where
11545  11546   
        S: ::tower::Service<
11546         -
                ::http::Request<Body>,
11547         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       11547  +
                ::http_1x::Request<Body>,
       11548  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
11548  11549   
                Error = ::std::convert::Infallible,
11549  11550   
            > + Clone
11550  11551   
            + Send
11551  11552   
            + 'static,
11552  11553   
        S::Future: Send + 'static,
11553  11554   
    {
11554  11555   
        self.null_and_empty_headers_client =
11555  11556   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
11556  11557   
        self
11557  11558   
    }
@@ -11581,11582 +11642,11643 @@
11601  11602   
                            <
11602  11603   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11603  11604   
                                as ::aws_smithy_http_server::plugin::Plugin<
11604  11605   
                                    RestJson<L>,
11605  11606   
                                    crate::operation_shape::NullAndEmptyHeadersServer,
11606  11607   
                                    ModelPl::Output
11607  11608   
                                >
11608  11609   
                            >::Output
11609  11610   
                        >,
11610  11611   
11611         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11612         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11612  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11613  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11613  11614   
11614  11615   
                    {
11615  11616   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11616  11617   
        use ::aws_smithy_http_server::plugin::Plugin;
11617  11618   
        let svc = crate::operation_shape::NullAndEmptyHeadersServer::from_handler(handler);
11618  11619   
        let svc = self.model_plugin.apply(svc);
11619  11620   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11620  11621   
            .apply(svc);
11621  11622   
        let svc = self.http_plugin.apply(svc);
11622  11623   
        self.null_and_empty_headers_server_custom(svc)
@@ -11648,11649 +11728,11729 @@
11668  11669   
                            <
11669  11670   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11670  11671   
                                as ::aws_smithy_http_server::plugin::Plugin<
11671  11672   
                                    RestJson<L>,
11672  11673   
                                    crate::operation_shape::NullAndEmptyHeadersServer,
11673  11674   
                                    ModelPl::Output
11674  11675   
                                >
11675  11676   
                            >::Output
11676  11677   
                        >,
11677  11678   
11678         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11679         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11679  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11680  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11680  11681   
11681  11682   
                    {
11682  11683   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11683  11684   
        use ::aws_smithy_http_server::plugin::Plugin;
11684  11685   
        let svc = crate::operation_shape::NullAndEmptyHeadersServer::from_service(service);
11685  11686   
        let svc = self.model_plugin.apply(svc);
11686  11687   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11687  11688   
            .apply(svc);
11688  11689   
        let svc = self.http_plugin.apply(svc);
11689  11690   
        self.null_and_empty_headers_server_custom(svc)
11690  11691   
    }
11691  11692   
11692  11693   
    /// Sets the [`NullAndEmptyHeadersServer`](crate::operation_shape::NullAndEmptyHeadersServer) to a custom [`Service`](tower::Service).
11693  11694   
    /// not constrained by the Smithy contract.
11694  11695   
    fn null_and_empty_headers_server_custom<S>(mut self, svc: S) -> Self
11695  11696   
    where
11696  11697   
        S: ::tower::Service<
11697         -
                ::http::Request<Body>,
11698         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       11698  +
                ::http_1x::Request<Body>,
       11699  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
11699  11700   
                Error = ::std::convert::Infallible,
11700  11701   
            > + Clone
11701  11702   
            + Send
11702  11703   
            + 'static,
11703  11704   
        S::Future: Send + 'static,
11704  11705   
    {
11705  11706   
        self.null_and_empty_headers_server =
11706  11707   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
11707  11708   
        self
11708  11709   
    }
@@ -11732,11733 +11793,11794 @@
11752  11753   
                            <
11753  11754   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11754  11755   
                                as ::aws_smithy_http_server::plugin::Plugin<
11755  11756   
                                    RestJson<L>,
11756  11757   
                                    crate::operation_shape::OmitsNullSerializesEmptyString,
11757  11758   
                                    ModelPl::Output
11758  11759   
                                >
11759  11760   
                            >::Output
11760  11761   
                        >,
11761  11762   
11762         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11763         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11763  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11764  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11764  11765   
11765  11766   
                    {
11766  11767   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11767  11768   
        use ::aws_smithy_http_server::plugin::Plugin;
11768  11769   
        let svc = crate::operation_shape::OmitsNullSerializesEmptyString::from_handler(handler);
11769  11770   
        let svc = self.model_plugin.apply(svc);
11770  11771   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11771  11772   
            .apply(svc);
11772  11773   
        let svc = self.http_plugin.apply(svc);
11773  11774   
        self.omits_null_serializes_empty_string_custom(svc)
@@ -11799,11800 +11879,11880 @@
11819  11820   
                            <
11820  11821   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11821  11822   
                                as ::aws_smithy_http_server::plugin::Plugin<
11822  11823   
                                    RestJson<L>,
11823  11824   
                                    crate::operation_shape::OmitsNullSerializesEmptyString,
11824  11825   
                                    ModelPl::Output
11825  11826   
                                >
11826  11827   
                            >::Output
11827  11828   
                        >,
11828  11829   
11829         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11830         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11830  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11831  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11831  11832   
11832  11833   
                    {
11833  11834   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11834  11835   
        use ::aws_smithy_http_server::plugin::Plugin;
11835  11836   
        let svc = crate::operation_shape::OmitsNullSerializesEmptyString::from_service(service);
11836  11837   
        let svc = self.model_plugin.apply(svc);
11837  11838   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11838  11839   
            .apply(svc);
11839  11840   
        let svc = self.http_plugin.apply(svc);
11840  11841   
        self.omits_null_serializes_empty_string_custom(svc)
11841  11842   
    }
11842  11843   
11843  11844   
    /// Sets the [`OmitsNullSerializesEmptyString`](crate::operation_shape::OmitsNullSerializesEmptyString) to a custom [`Service`](tower::Service).
11844  11845   
    /// not constrained by the Smithy contract.
11845  11846   
    fn omits_null_serializes_empty_string_custom<S>(mut self, svc: S) -> Self
11846  11847   
    where
11847  11848   
        S: ::tower::Service<
11848         -
                ::http::Request<Body>,
11849         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       11849  +
                ::http_1x::Request<Body>,
       11850  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
11850  11851   
                Error = ::std::convert::Infallible,
11851  11852   
            > + Clone
11852  11853   
            + Send
11853  11854   
            + 'static,
11854  11855   
        S::Future: Send + 'static,
11855  11856   
    {
11856  11857   
        self.omits_null_serializes_empty_string =
11857  11858   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
11858  11859   
        self
11859  11860   
    }
@@ -11883,11884 +11944,11945 @@
11903  11904   
                            <
11904  11905   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11905  11906   
                                as ::aws_smithy_http_server::plugin::Plugin<
11906  11907   
                                    RestJson<L>,
11907  11908   
                                    crate::operation_shape::OmitsSerializingEmptyLists,
11908  11909   
                                    ModelPl::Output
11909  11910   
                                >
11910  11911   
                            >::Output
11911  11912   
                        >,
11912  11913   
11913         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11914         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11914  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11915  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11915  11916   
11916  11917   
                    {
11917  11918   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11918  11919   
        use ::aws_smithy_http_server::plugin::Plugin;
11919  11920   
        let svc = crate::operation_shape::OmitsSerializingEmptyLists::from_handler(handler);
11920  11921   
        let svc = self.model_plugin.apply(svc);
11921  11922   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11922  11923   
            .apply(svc);
11923  11924   
        let svc = self.http_plugin.apply(svc);
11924  11925   
        self.omits_serializing_empty_lists_custom(svc)
@@ -11950,11951 +12030,12031 @@
11970  11971   
                            <
11971  11972   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
11972  11973   
                                as ::aws_smithy_http_server::plugin::Plugin<
11973  11974   
                                    RestJson<L>,
11974  11975   
                                    crate::operation_shape::OmitsSerializingEmptyLists,
11975  11976   
                                    ModelPl::Output
11976  11977   
                                >
11977  11978   
                            >::Output
11978  11979   
                        >,
11979  11980   
11980         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
11981         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       11981  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       11982  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
11982  11983   
11983  11984   
                    {
11984  11985   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
11985  11986   
        use ::aws_smithy_http_server::plugin::Plugin;
11986  11987   
        let svc = crate::operation_shape::OmitsSerializingEmptyLists::from_service(service);
11987  11988   
        let svc = self.model_plugin.apply(svc);
11988  11989   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
11989  11990   
            .apply(svc);
11990  11991   
        let svc = self.http_plugin.apply(svc);
11991  11992   
        self.omits_serializing_empty_lists_custom(svc)
11992  11993   
    }
11993  11994   
11994  11995   
    /// Sets the [`OmitsSerializingEmptyLists`](crate::operation_shape::OmitsSerializingEmptyLists) to a custom [`Service`](tower::Service).
11995  11996   
    /// not constrained by the Smithy contract.
11996  11997   
    fn omits_serializing_empty_lists_custom<S>(mut self, svc: S) -> Self
11997  11998   
    where
11998  11999   
        S: ::tower::Service<
11999         -
                ::http::Request<Body>,
12000         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12000  +
                ::http_1x::Request<Body>,
       12001  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12001  12002   
                Error = ::std::convert::Infallible,
12002  12003   
            > + Clone
12003  12004   
            + Send
12004  12005   
            + 'static,
12005  12006   
        S::Future: Send + 'static,
12006  12007   
    {
12007  12008   
        self.omits_serializing_empty_lists =
12008  12009   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
12009  12010   
        self
12010  12011   
    }
@@ -12034,12035 +12095,12096 @@
12054  12055   
                            <
12055  12056   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12056  12057   
                                as ::aws_smithy_http_server::plugin::Plugin<
12057  12058   
                                    RestJson<L>,
12058  12059   
                                    crate::operation_shape::OperationWithDefaults,
12059  12060   
                                    ModelPl::Output
12060  12061   
                                >
12061  12062   
                            >::Output
12062  12063   
                        >,
12063  12064   
12064         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12065         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12065  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12066  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12066  12067   
12067  12068   
                    {
12068  12069   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12069  12070   
        use ::aws_smithy_http_server::plugin::Plugin;
12070  12071   
        let svc = crate::operation_shape::OperationWithDefaults::from_handler(handler);
12071  12072   
        let svc = self.model_plugin.apply(svc);
12072  12073   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12073  12074   
            .apply(svc);
12074  12075   
        let svc = self.http_plugin.apply(svc);
12075  12076   
        self.operation_with_defaults_custom(svc)
@@ -12101,12102 +12181,12182 @@
12121  12122   
                            <
12122  12123   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12123  12124   
                                as ::aws_smithy_http_server::plugin::Plugin<
12124  12125   
                                    RestJson<L>,
12125  12126   
                                    crate::operation_shape::OperationWithDefaults,
12126  12127   
                                    ModelPl::Output
12127  12128   
                                >
12128  12129   
                            >::Output
12129  12130   
                        >,
12130  12131   
12131         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12132         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12132  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12133  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12133  12134   
12134  12135   
                    {
12135  12136   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12136  12137   
        use ::aws_smithy_http_server::plugin::Plugin;
12137  12138   
        let svc = crate::operation_shape::OperationWithDefaults::from_service(service);
12138  12139   
        let svc = self.model_plugin.apply(svc);
12139  12140   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12140  12141   
            .apply(svc);
12141  12142   
        let svc = self.http_plugin.apply(svc);
12142  12143   
        self.operation_with_defaults_custom(svc)
12143  12144   
    }
12144  12145   
12145  12146   
    /// Sets the [`OperationWithDefaults`](crate::operation_shape::OperationWithDefaults) to a custom [`Service`](tower::Service).
12146  12147   
    /// not constrained by the Smithy contract.
12147  12148   
    fn operation_with_defaults_custom<S>(mut self, svc: S) -> Self
12148  12149   
    where
12149  12150   
        S: ::tower::Service<
12150         -
                ::http::Request<Body>,
12151         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12151  +
                ::http_1x::Request<Body>,
       12152  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12152  12153   
                Error = ::std::convert::Infallible,
12153  12154   
            > + Clone
12154  12155   
            + Send
12155  12156   
            + 'static,
12156  12157   
        S::Future: Send + 'static,
12157  12158   
    {
12158  12159   
        self.operation_with_defaults = Some(::aws_smithy_http_server::routing::Route::new(svc));
12159  12160   
        self
12160  12161   
    }
12161  12162
@@ -12184,12185 +12245,12246 @@
12204  12205   
                            <
12205  12206   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12206  12207   
                                as ::aws_smithy_http_server::plugin::Plugin<
12207  12208   
                                    RestJson<L>,
12208  12209   
                                    crate::operation_shape::OperationWithNestedStructure,
12209  12210   
                                    ModelPl::Output
12210  12211   
                                >
12211  12212   
                            >::Output
12212  12213   
                        >,
12213  12214   
12214         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12215         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12215  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12216  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12216  12217   
12217  12218   
                    {
12218  12219   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12219  12220   
        use ::aws_smithy_http_server::plugin::Plugin;
12220  12221   
        let svc = crate::operation_shape::OperationWithNestedStructure::from_handler(handler);
12221  12222   
        let svc = self.model_plugin.apply(svc);
12222  12223   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12223  12224   
            .apply(svc);
12224  12225   
        let svc = self.http_plugin.apply(svc);
12225  12226   
        self.operation_with_nested_structure_custom(svc)
@@ -12251,12252 +12331,12332 @@
12271  12272   
                            <
12272  12273   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12273  12274   
                                as ::aws_smithy_http_server::plugin::Plugin<
12274  12275   
                                    RestJson<L>,
12275  12276   
                                    crate::operation_shape::OperationWithNestedStructure,
12276  12277   
                                    ModelPl::Output
12277  12278   
                                >
12278  12279   
                            >::Output
12279  12280   
                        >,
12280  12281   
12281         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12282         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12282  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12283  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12283  12284   
12284  12285   
                    {
12285  12286   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12286  12287   
        use ::aws_smithy_http_server::plugin::Plugin;
12287  12288   
        let svc = crate::operation_shape::OperationWithNestedStructure::from_service(service);
12288  12289   
        let svc = self.model_plugin.apply(svc);
12289  12290   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12290  12291   
            .apply(svc);
12291  12292   
        let svc = self.http_plugin.apply(svc);
12292  12293   
        self.operation_with_nested_structure_custom(svc)
12293  12294   
    }
12294  12295   
12295  12296   
    /// Sets the [`OperationWithNestedStructure`](crate::operation_shape::OperationWithNestedStructure) to a custom [`Service`](tower::Service).
12296  12297   
    /// not constrained by the Smithy contract.
12297  12298   
    fn operation_with_nested_structure_custom<S>(mut self, svc: S) -> Self
12298  12299   
    where
12299  12300   
        S: ::tower::Service<
12300         -
                ::http::Request<Body>,
12301         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12301  +
                ::http_1x::Request<Body>,
       12302  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12302  12303   
                Error = ::std::convert::Infallible,
12303  12304   
            > + Clone
12304  12305   
            + Send
12305  12306   
            + 'static,
12306  12307   
        S::Future: Send + 'static,
12307  12308   
    {
12308  12309   
        self.operation_with_nested_structure =
12309  12310   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
12310  12311   
        self
12311  12312   
    }
@@ -12335,12336 +12396,12397 @@
12355  12356   
                            <
12356  12357   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12357  12358   
                                as ::aws_smithy_http_server::plugin::Plugin<
12358  12359   
                                    RestJson<L>,
12359  12360   
                                    crate::operation_shape::PostPlayerAction,
12360  12361   
                                    ModelPl::Output
12361  12362   
                                >
12362  12363   
                            >::Output
12363  12364   
                        >,
12364  12365   
12365         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12366         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12366  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12367  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12367  12368   
12368  12369   
                    {
12369  12370   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12370  12371   
        use ::aws_smithy_http_server::plugin::Plugin;
12371  12372   
        let svc = crate::operation_shape::PostPlayerAction::from_handler(handler);
12372  12373   
        let svc = self.model_plugin.apply(svc);
12373  12374   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12374  12375   
            .apply(svc);
12375  12376   
        let svc = self.http_plugin.apply(svc);
12376  12377   
        self.post_player_action_custom(svc)
@@ -12402,12403 +12482,12483 @@
12422  12423   
                            <
12423  12424   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12424  12425   
                                as ::aws_smithy_http_server::plugin::Plugin<
12425  12426   
                                    RestJson<L>,
12426  12427   
                                    crate::operation_shape::PostPlayerAction,
12427  12428   
                                    ModelPl::Output
12428  12429   
                                >
12429  12430   
                            >::Output
12430  12431   
                        >,
12431  12432   
12432         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12433         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12433  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12434  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12434  12435   
12435  12436   
                    {
12436  12437   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12437  12438   
        use ::aws_smithy_http_server::plugin::Plugin;
12438  12439   
        let svc = crate::operation_shape::PostPlayerAction::from_service(service);
12439  12440   
        let svc = self.model_plugin.apply(svc);
12440  12441   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12441  12442   
            .apply(svc);
12442  12443   
        let svc = self.http_plugin.apply(svc);
12443  12444   
        self.post_player_action_custom(svc)
12444  12445   
    }
12445  12446   
12446  12447   
    /// Sets the [`PostPlayerAction`](crate::operation_shape::PostPlayerAction) to a custom [`Service`](tower::Service).
12447  12448   
    /// not constrained by the Smithy contract.
12448  12449   
    fn post_player_action_custom<S>(mut self, svc: S) -> Self
12449  12450   
    where
12450  12451   
        S: ::tower::Service<
12451         -
                ::http::Request<Body>,
12452         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12452  +
                ::http_1x::Request<Body>,
       12453  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12453  12454   
                Error = ::std::convert::Infallible,
12454  12455   
            > + Clone
12455  12456   
            + Send
12456  12457   
            + 'static,
12457  12458   
        S::Future: Send + 'static,
12458  12459   
    {
12459  12460   
        self.post_player_action = Some(::aws_smithy_http_server::routing::Route::new(svc));
12460  12461   
        self
12461  12462   
    }
12462  12463
@@ -12485,12486 +12546,12547 @@
12505  12506   
                            <
12506  12507   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12507  12508   
                                as ::aws_smithy_http_server::plugin::Plugin<
12508  12509   
                                    RestJson<L>,
12509  12510   
                                    crate::operation_shape::PostUnionWithJsonName,
12510  12511   
                                    ModelPl::Output
12511  12512   
                                >
12512  12513   
                            >::Output
12513  12514   
                        >,
12514  12515   
12515         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12516         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12516  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12517  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12517  12518   
12518  12519   
                    {
12519  12520   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12520  12521   
        use ::aws_smithy_http_server::plugin::Plugin;
12521  12522   
        let svc = crate::operation_shape::PostUnionWithJsonName::from_handler(handler);
12522  12523   
        let svc = self.model_plugin.apply(svc);
12523  12524   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12524  12525   
            .apply(svc);
12525  12526   
        let svc = self.http_plugin.apply(svc);
12526  12527   
        self.post_union_with_json_name_custom(svc)
@@ -12552,12553 +12632,12633 @@
12572  12573   
                            <
12573  12574   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12574  12575   
                                as ::aws_smithy_http_server::plugin::Plugin<
12575  12576   
                                    RestJson<L>,
12576  12577   
                                    crate::operation_shape::PostUnionWithJsonName,
12577  12578   
                                    ModelPl::Output
12578  12579   
                                >
12579  12580   
                            >::Output
12580  12581   
                        >,
12581  12582   
12582         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12583         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12583  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12584  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12584  12585   
12585  12586   
                    {
12586  12587   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12587  12588   
        use ::aws_smithy_http_server::plugin::Plugin;
12588  12589   
        let svc = crate::operation_shape::PostUnionWithJsonName::from_service(service);
12589  12590   
        let svc = self.model_plugin.apply(svc);
12590  12591   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12591  12592   
            .apply(svc);
12592  12593   
        let svc = self.http_plugin.apply(svc);
12593  12594   
        self.post_union_with_json_name_custom(svc)
12594  12595   
    }
12595  12596   
12596  12597   
    /// Sets the [`PostUnionWithJsonName`](crate::operation_shape::PostUnionWithJsonName) to a custom [`Service`](tower::Service).
12597  12598   
    /// not constrained by the Smithy contract.
12598  12599   
    fn post_union_with_json_name_custom<S>(mut self, svc: S) -> Self
12599  12600   
    where
12600  12601   
        S: ::tower::Service<
12601         -
                ::http::Request<Body>,
12602         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12602  +
                ::http_1x::Request<Body>,
       12603  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12603  12604   
                Error = ::std::convert::Infallible,
12604  12605   
            > + Clone
12605  12606   
            + Send
12606  12607   
            + 'static,
12607  12608   
        S::Future: Send + 'static,
12608  12609   
    {
12609  12610   
        self.post_union_with_json_name = Some(::aws_smithy_http_server::routing::Route::new(svc));
12610  12611   
        self
12611  12612   
    }
12612  12613
@@ -12635,12636 +12696,12697 @@
12655  12656   
                            <
12656  12657   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12657  12658   
                                as ::aws_smithy_http_server::plugin::Plugin<
12658  12659   
                                    RestJson<L>,
12659  12660   
                                    crate::operation_shape::PutWithContentEncoding,
12660  12661   
                                    ModelPl::Output
12661  12662   
                                >
12662  12663   
                            >::Output
12663  12664   
                        >,
12664  12665   
12665         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12666         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12666  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12667  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12667  12668   
12668  12669   
                    {
12669  12670   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12670  12671   
        use ::aws_smithy_http_server::plugin::Plugin;
12671  12672   
        let svc = crate::operation_shape::PutWithContentEncoding::from_handler(handler);
12672  12673   
        let svc = self.model_plugin.apply(svc);
12673  12674   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12674  12675   
            .apply(svc);
12675  12676   
        let svc = self.http_plugin.apply(svc);
12676  12677   
        self.put_with_content_encoding_custom(svc)
@@ -12702,12703 +12782,12783 @@
12722  12723   
                            <
12723  12724   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12724  12725   
                                as ::aws_smithy_http_server::plugin::Plugin<
12725  12726   
                                    RestJson<L>,
12726  12727   
                                    crate::operation_shape::PutWithContentEncoding,
12727  12728   
                                    ModelPl::Output
12728  12729   
                                >
12729  12730   
                            >::Output
12730  12731   
                        >,
12731  12732   
12732         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12733         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12733  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12734  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12734  12735   
12735  12736   
                    {
12736  12737   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12737  12738   
        use ::aws_smithy_http_server::plugin::Plugin;
12738  12739   
        let svc = crate::operation_shape::PutWithContentEncoding::from_service(service);
12739  12740   
        let svc = self.model_plugin.apply(svc);
12740  12741   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12741  12742   
            .apply(svc);
12742  12743   
        let svc = self.http_plugin.apply(svc);
12743  12744   
        self.put_with_content_encoding_custom(svc)
12744  12745   
    }
12745  12746   
12746  12747   
    /// Sets the [`PutWithContentEncoding`](crate::operation_shape::PutWithContentEncoding) to a custom [`Service`](tower::Service).
12747  12748   
    /// not constrained by the Smithy contract.
12748  12749   
    fn put_with_content_encoding_custom<S>(mut self, svc: S) -> Self
12749  12750   
    where
12750  12751   
        S: ::tower::Service<
12751         -
                ::http::Request<Body>,
12752         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12752  +
                ::http_1x::Request<Body>,
       12753  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12753  12754   
                Error = ::std::convert::Infallible,
12754  12755   
            > + Clone
12755  12756   
            + Send
12756  12757   
            + 'static,
12757  12758   
        S::Future: Send + 'static,
12758  12759   
    {
12759  12760   
        self.put_with_content_encoding = Some(::aws_smithy_http_server::routing::Route::new(svc));
12760  12761   
        self
12761  12762   
    }
12762  12763
@@ -12785,12786 +12846,12847 @@
12805  12806   
                            <
12806  12807   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12807  12808   
                                as ::aws_smithy_http_server::plugin::Plugin<
12808  12809   
                                    RestJson<L>,
12809  12810   
                                    crate::operation_shape::QueryIdempotencyTokenAutoFill,
12810  12811   
                                    ModelPl::Output
12811  12812   
                                >
12812  12813   
                            >::Output
12813  12814   
                        >,
12814  12815   
12815         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12816         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12816  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12817  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12817  12818   
12818  12819   
                    {
12819  12820   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12820  12821   
        use ::aws_smithy_http_server::plugin::Plugin;
12821  12822   
        let svc = crate::operation_shape::QueryIdempotencyTokenAutoFill::from_handler(handler);
12822  12823   
        let svc = self.model_plugin.apply(svc);
12823  12824   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12824  12825   
            .apply(svc);
12825  12826   
        let svc = self.http_plugin.apply(svc);
12826  12827   
        self.query_idempotency_token_auto_fill_custom(svc)
@@ -12852,12853 +12932,12933 @@
12872  12873   
                            <
12873  12874   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12874  12875   
                                as ::aws_smithy_http_server::plugin::Plugin<
12875  12876   
                                    RestJson<L>,
12876  12877   
                                    crate::operation_shape::QueryIdempotencyTokenAutoFill,
12877  12878   
                                    ModelPl::Output
12878  12879   
                                >
12879  12880   
                            >::Output
12880  12881   
                        >,
12881  12882   
12882         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12883         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12883  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12884  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12884  12885   
12885  12886   
                    {
12886  12887   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12887  12888   
        use ::aws_smithy_http_server::plugin::Plugin;
12888  12889   
        let svc = crate::operation_shape::QueryIdempotencyTokenAutoFill::from_service(service);
12889  12890   
        let svc = self.model_plugin.apply(svc);
12890  12891   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12891  12892   
            .apply(svc);
12892  12893   
        let svc = self.http_plugin.apply(svc);
12893  12894   
        self.query_idempotency_token_auto_fill_custom(svc)
12894  12895   
    }
12895  12896   
12896  12897   
    /// Sets the [`QueryIdempotencyTokenAutoFill`](crate::operation_shape::QueryIdempotencyTokenAutoFill) to a custom [`Service`](tower::Service).
12897  12898   
    /// not constrained by the Smithy contract.
12898  12899   
    fn query_idempotency_token_auto_fill_custom<S>(mut self, svc: S) -> Self
12899  12900   
    where
12900  12901   
        S: ::tower::Service<
12901         -
                ::http::Request<Body>,
12902         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       12902  +
                ::http_1x::Request<Body>,
       12903  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
12903  12904   
                Error = ::std::convert::Infallible,
12904  12905   
            > + Clone
12905  12906   
            + Send
12906  12907   
            + 'static,
12907  12908   
        S::Future: Send + 'static,
12908  12909   
    {
12909  12910   
        self.query_idempotency_token_auto_fill =
12910  12911   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
12911  12912   
        self
12912  12913   
    }
@@ -12936,12937 +12997,12998 @@
12956  12957   
                            <
12957  12958   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
12958  12959   
                                as ::aws_smithy_http_server::plugin::Plugin<
12959  12960   
                                    RestJson<L>,
12960  12961   
                                    crate::operation_shape::QueryParamsAsStringListMap,
12961  12962   
                                    ModelPl::Output
12962  12963   
                                >
12963  12964   
                            >::Output
12964  12965   
                        >,
12965  12966   
12966         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
12967         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       12967  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       12968  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
12968  12969   
12969  12970   
                    {
12970  12971   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
12971  12972   
        use ::aws_smithy_http_server::plugin::Plugin;
12972  12973   
        let svc = crate::operation_shape::QueryParamsAsStringListMap::from_handler(handler);
12973  12974   
        let svc = self.model_plugin.apply(svc);
12974  12975   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
12975  12976   
            .apply(svc);
12976  12977   
        let svc = self.http_plugin.apply(svc);
12977  12978   
        self.query_params_as_string_list_map_custom(svc)
@@ -13003,13004 +13083,13084 @@
13023  13024   
                            <
13024  13025   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13025  13026   
                                as ::aws_smithy_http_server::plugin::Plugin<
13026  13027   
                                    RestJson<L>,
13027  13028   
                                    crate::operation_shape::QueryParamsAsStringListMap,
13028  13029   
                                    ModelPl::Output
13029  13030   
                                >
13030  13031   
                            >::Output
13031  13032   
                        >,
13032  13033   
13033         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13034         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13034  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13035  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13035  13036   
13036  13037   
                    {
13037  13038   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13038  13039   
        use ::aws_smithy_http_server::plugin::Plugin;
13039  13040   
        let svc = crate::operation_shape::QueryParamsAsStringListMap::from_service(service);
13040  13041   
        let svc = self.model_plugin.apply(svc);
13041  13042   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13042  13043   
            .apply(svc);
13043  13044   
        let svc = self.http_plugin.apply(svc);
13044  13045   
        self.query_params_as_string_list_map_custom(svc)
13045  13046   
    }
13046  13047   
13047  13048   
    /// Sets the [`QueryParamsAsStringListMap`](crate::operation_shape::QueryParamsAsStringListMap) to a custom [`Service`](tower::Service).
13048  13049   
    /// not constrained by the Smithy contract.
13049  13050   
    fn query_params_as_string_list_map_custom<S>(mut self, svc: S) -> Self
13050  13051   
    where
13051  13052   
        S: ::tower::Service<
13052         -
                ::http::Request<Body>,
13053         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13053  +
                ::http_1x::Request<Body>,
       13054  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13054  13055   
                Error = ::std::convert::Infallible,
13055  13056   
            > + Clone
13056  13057   
            + Send
13057  13058   
            + 'static,
13058  13059   
        S::Future: Send + 'static,
13059  13060   
    {
13060  13061   
        self.query_params_as_string_list_map =
13061  13062   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
13062  13063   
        self
13063  13064   
    }
@@ -13087,13088 +13148,13149 @@
13107  13108   
                            <
13108  13109   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13109  13110   
                                as ::aws_smithy_http_server::plugin::Plugin<
13110  13111   
                                    RestJson<L>,
13111  13112   
                                    crate::operation_shape::QueryPrecedence,
13112  13113   
                                    ModelPl::Output
13113  13114   
                                >
13114  13115   
                            >::Output
13115  13116   
                        >,
13116  13117   
13117         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13118         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13118  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13119  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13119  13120   
13120  13121   
                    {
13121  13122   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13122  13123   
        use ::aws_smithy_http_server::plugin::Plugin;
13123  13124   
        let svc = crate::operation_shape::QueryPrecedence::from_handler(handler);
13124  13125   
        let svc = self.model_plugin.apply(svc);
13125  13126   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13126  13127   
            .apply(svc);
13127  13128   
        let svc = self.http_plugin.apply(svc);
13128  13129   
        self.query_precedence_custom(svc)
@@ -13154,13155 +13234,13235 @@
13174  13175   
                            <
13175  13176   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13176  13177   
                                as ::aws_smithy_http_server::plugin::Plugin<
13177  13178   
                                    RestJson<L>,
13178  13179   
                                    crate::operation_shape::QueryPrecedence,
13179  13180   
                                    ModelPl::Output
13180  13181   
                                >
13181  13182   
                            >::Output
13182  13183   
                        >,
13183  13184   
13184         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13185         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13185  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13186  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13186  13187   
13187  13188   
                    {
13188  13189   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13189  13190   
        use ::aws_smithy_http_server::plugin::Plugin;
13190  13191   
        let svc = crate::operation_shape::QueryPrecedence::from_service(service);
13191  13192   
        let svc = self.model_plugin.apply(svc);
13192  13193   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13193  13194   
            .apply(svc);
13194  13195   
        let svc = self.http_plugin.apply(svc);
13195  13196   
        self.query_precedence_custom(svc)
13196  13197   
    }
13197  13198   
13198  13199   
    /// Sets the [`QueryPrecedence`](crate::operation_shape::QueryPrecedence) to a custom [`Service`](tower::Service).
13199  13200   
    /// not constrained by the Smithy contract.
13200  13201   
    fn query_precedence_custom<S>(mut self, svc: S) -> Self
13201  13202   
    where
13202  13203   
        S: ::tower::Service<
13203         -
                ::http::Request<Body>,
13204         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13204  +
                ::http_1x::Request<Body>,
       13205  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13205  13206   
                Error = ::std::convert::Infallible,
13206  13207   
            > + Clone
13207  13208   
            + Send
13208  13209   
            + 'static,
13209  13210   
        S::Future: Send + 'static,
13210  13211   
    {
13211  13212   
        self.query_precedence = Some(::aws_smithy_http_server::routing::Route::new(svc));
13212  13213   
        self
13213  13214   
    }
13214  13215
@@ -13237,13238 +13298,13299 @@
13257  13258   
                            <
13258  13259   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13259  13260   
                                as ::aws_smithy_http_server::plugin::Plugin<
13260  13261   
                                    RestJson<L>,
13261  13262   
                                    crate::operation_shape::RecursiveShapes,
13262  13263   
                                    ModelPl::Output
13263  13264   
                                >
13264  13265   
                            >::Output
13265  13266   
                        >,
13266  13267   
13267         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13268         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13268  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13269  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13269  13270   
13270  13271   
                    {
13271  13272   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13272  13273   
        use ::aws_smithy_http_server::plugin::Plugin;
13273  13274   
        let svc = crate::operation_shape::RecursiveShapes::from_handler(handler);
13274  13275   
        let svc = self.model_plugin.apply(svc);
13275  13276   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13276  13277   
            .apply(svc);
13277  13278   
        let svc = self.http_plugin.apply(svc);
13278  13279   
        self.recursive_shapes_custom(svc)
@@ -13304,13305 +13384,13385 @@
13324  13325   
                            <
13325  13326   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13326  13327   
                                as ::aws_smithy_http_server::plugin::Plugin<
13327  13328   
                                    RestJson<L>,
13328  13329   
                                    crate::operation_shape::RecursiveShapes,
13329  13330   
                                    ModelPl::Output
13330  13331   
                                >
13331  13332   
                            >::Output
13332  13333   
                        >,
13333  13334   
13334         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13335         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13335  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13336  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13336  13337   
13337  13338   
                    {
13338  13339   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13339  13340   
        use ::aws_smithy_http_server::plugin::Plugin;
13340  13341   
        let svc = crate::operation_shape::RecursiveShapes::from_service(service);
13341  13342   
        let svc = self.model_plugin.apply(svc);
13342  13343   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13343  13344   
            .apply(svc);
13344  13345   
        let svc = self.http_plugin.apply(svc);
13345  13346   
        self.recursive_shapes_custom(svc)
13346  13347   
    }
13347  13348   
13348  13349   
    /// Sets the [`RecursiveShapes`](crate::operation_shape::RecursiveShapes) to a custom [`Service`](tower::Service).
13349  13350   
    /// not constrained by the Smithy contract.
13350  13351   
    fn recursive_shapes_custom<S>(mut self, svc: S) -> Self
13351  13352   
    where
13352  13353   
        S: ::tower::Service<
13353         -
                ::http::Request<Body>,
13354         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13354  +
                ::http_1x::Request<Body>,
       13355  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13355  13356   
                Error = ::std::convert::Infallible,
13356  13357   
            > + Clone
13357  13358   
            + Send
13358  13359   
            + 'static,
13359  13360   
        S::Future: Send + 'static,
13360  13361   
    {
13361  13362   
        self.recursive_shapes = Some(::aws_smithy_http_server::routing::Route::new(svc));
13362  13363   
        self
13363  13364   
    }
13364  13365
@@ -13387,13388 +13448,13449 @@
13407  13408   
                            <
13408  13409   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13409  13410   
                                as ::aws_smithy_http_server::plugin::Plugin<
13410  13411   
                                    RestJson<L>,
13411  13412   
                                    crate::operation_shape::ResponseCodeHttpFallback,
13412  13413   
                                    ModelPl::Output
13413  13414   
                                >
13414  13415   
                            >::Output
13415  13416   
                        >,
13416  13417   
13417         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13418         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13418  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13419  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13419  13420   
13420  13421   
                    {
13421  13422   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13422  13423   
        use ::aws_smithy_http_server::plugin::Plugin;
13423  13424   
        let svc = crate::operation_shape::ResponseCodeHttpFallback::from_handler(handler);
13424  13425   
        let svc = self.model_plugin.apply(svc);
13425  13426   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13426  13427   
            .apply(svc);
13427  13428   
        let svc = self.http_plugin.apply(svc);
13428  13429   
        self.response_code_http_fallback_custom(svc)
@@ -13454,13455 +13534,13535 @@
13474  13475   
                            <
13475  13476   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13476  13477   
                                as ::aws_smithy_http_server::plugin::Plugin<
13477  13478   
                                    RestJson<L>,
13478  13479   
                                    crate::operation_shape::ResponseCodeHttpFallback,
13479  13480   
                                    ModelPl::Output
13480  13481   
                                >
13481  13482   
                            >::Output
13482  13483   
                        >,
13483  13484   
13484         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13485         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13485  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13486  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13486  13487   
13487  13488   
                    {
13488  13489   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13489  13490   
        use ::aws_smithy_http_server::plugin::Plugin;
13490  13491   
        let svc = crate::operation_shape::ResponseCodeHttpFallback::from_service(service);
13491  13492   
        let svc = self.model_plugin.apply(svc);
13492  13493   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13493  13494   
            .apply(svc);
13494  13495   
        let svc = self.http_plugin.apply(svc);
13495  13496   
        self.response_code_http_fallback_custom(svc)
13496  13497   
    }
13497  13498   
13498  13499   
    /// Sets the [`ResponseCodeHttpFallback`](crate::operation_shape::ResponseCodeHttpFallback) to a custom [`Service`](tower::Service).
13499  13500   
    /// not constrained by the Smithy contract.
13500  13501   
    fn response_code_http_fallback_custom<S>(mut self, svc: S) -> Self
13501  13502   
    where
13502  13503   
        S: ::tower::Service<
13503         -
                ::http::Request<Body>,
13504         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13504  +
                ::http_1x::Request<Body>,
       13505  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13505  13506   
                Error = ::std::convert::Infallible,
13506  13507   
            > + Clone
13507  13508   
            + Send
13508  13509   
            + 'static,
13509  13510   
        S::Future: Send + 'static,
13510  13511   
    {
13511  13512   
        self.response_code_http_fallback = Some(::aws_smithy_http_server::routing::Route::new(svc));
13512  13513   
        self
13513  13514   
    }
13514  13515
@@ -13537,13538 +13598,13599 @@
13557  13558   
                            <
13558  13559   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13559  13560   
                                as ::aws_smithy_http_server::plugin::Plugin<
13560  13561   
                                    RestJson<L>,
13561  13562   
                                    crate::operation_shape::ResponseCodeRequired,
13562  13563   
                                    ModelPl::Output
13563  13564   
                                >
13564  13565   
                            >::Output
13565  13566   
                        >,
13566  13567   
13567         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13568         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13568  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13569  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13569  13570   
13570  13571   
                    {
13571  13572   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13572  13573   
        use ::aws_smithy_http_server::plugin::Plugin;
13573  13574   
        let svc = crate::operation_shape::ResponseCodeRequired::from_handler(handler);
13574  13575   
        let svc = self.model_plugin.apply(svc);
13575  13576   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13576  13577   
            .apply(svc);
13577  13578   
        let svc = self.http_plugin.apply(svc);
13578  13579   
        self.response_code_required_custom(svc)
@@ -13604,13605 +13684,13685 @@
13624  13625   
                            <
13625  13626   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13626  13627   
                                as ::aws_smithy_http_server::plugin::Plugin<
13627  13628   
                                    RestJson<L>,
13628  13629   
                                    crate::operation_shape::ResponseCodeRequired,
13629  13630   
                                    ModelPl::Output
13630  13631   
                                >
13631  13632   
                            >::Output
13632  13633   
                        >,
13633  13634   
13634         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13635         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13635  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13636  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13636  13637   
13637  13638   
                    {
13638  13639   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13639  13640   
        use ::aws_smithy_http_server::plugin::Plugin;
13640  13641   
        let svc = crate::operation_shape::ResponseCodeRequired::from_service(service);
13641  13642   
        let svc = self.model_plugin.apply(svc);
13642  13643   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13643  13644   
            .apply(svc);
13644  13645   
        let svc = self.http_plugin.apply(svc);
13645  13646   
        self.response_code_required_custom(svc)
13646  13647   
    }
13647  13648   
13648  13649   
    /// Sets the [`ResponseCodeRequired`](crate::operation_shape::ResponseCodeRequired) to a custom [`Service`](tower::Service).
13649  13650   
    /// not constrained by the Smithy contract.
13650  13651   
    fn response_code_required_custom<S>(mut self, svc: S) -> Self
13651  13652   
    where
13652  13653   
        S: ::tower::Service<
13653         -
                ::http::Request<Body>,
13654         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13654  +
                ::http_1x::Request<Body>,
       13655  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13655  13656   
                Error = ::std::convert::Infallible,
13656  13657   
            > + Clone
13657  13658   
            + Send
13658  13659   
            + 'static,
13659  13660   
        S::Future: Send + 'static,
13660  13661   
    {
13661  13662   
        self.response_code_required = Some(::aws_smithy_http_server::routing::Route::new(svc));
13662  13663   
        self
13663  13664   
    }
13664  13665
@@ -13687,13688 +13748,13749 @@
13707  13708   
                            <
13708  13709   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13709  13710   
                                as ::aws_smithy_http_server::plugin::Plugin<
13710  13711   
                                    RestJson<L>,
13711  13712   
                                    crate::operation_shape::SimpleScalarProperties,
13712  13713   
                                    ModelPl::Output
13713  13714   
                                >
13714  13715   
                            >::Output
13715  13716   
                        >,
13716  13717   
13717         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13718         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13718  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13719  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13719  13720   
13720  13721   
                    {
13721  13722   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13722  13723   
        use ::aws_smithy_http_server::plugin::Plugin;
13723  13724   
        let svc = crate::operation_shape::SimpleScalarProperties::from_handler(handler);
13724  13725   
        let svc = self.model_plugin.apply(svc);
13725  13726   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13726  13727   
            .apply(svc);
13727  13728   
        let svc = self.http_plugin.apply(svc);
13728  13729   
        self.simple_scalar_properties_custom(svc)
@@ -13754,13755 +13834,13835 @@
13774  13775   
                            <
13775  13776   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13776  13777   
                                as ::aws_smithy_http_server::plugin::Plugin<
13777  13778   
                                    RestJson<L>,
13778  13779   
                                    crate::operation_shape::SimpleScalarProperties,
13779  13780   
                                    ModelPl::Output
13780  13781   
                                >
13781  13782   
                            >::Output
13782  13783   
                        >,
13783  13784   
13784         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13785         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13785  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13786  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13786  13787   
13787  13788   
                    {
13788  13789   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13789  13790   
        use ::aws_smithy_http_server::plugin::Plugin;
13790  13791   
        let svc = crate::operation_shape::SimpleScalarProperties::from_service(service);
13791  13792   
        let svc = self.model_plugin.apply(svc);
13792  13793   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13793  13794   
            .apply(svc);
13794  13795   
        let svc = self.http_plugin.apply(svc);
13795  13796   
        self.simple_scalar_properties_custom(svc)
13796  13797   
    }
13797  13798   
13798  13799   
    /// Sets the [`SimpleScalarProperties`](crate::operation_shape::SimpleScalarProperties) to a custom [`Service`](tower::Service).
13799  13800   
    /// not constrained by the Smithy contract.
13800  13801   
    fn simple_scalar_properties_custom<S>(mut self, svc: S) -> Self
13801  13802   
    where
13802  13803   
        S: ::tower::Service<
13803         -
                ::http::Request<Body>,
13804         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13804  +
                ::http_1x::Request<Body>,
       13805  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13805  13806   
                Error = ::std::convert::Infallible,
13806  13807   
            > + Clone
13807  13808   
            + Send
13808  13809   
            + 'static,
13809  13810   
        S::Future: Send + 'static,
13810  13811   
    {
13811  13812   
        self.simple_scalar_properties = Some(::aws_smithy_http_server::routing::Route::new(svc));
13812  13813   
        self
13813  13814   
    }
13814  13815
@@ -13837,13838 +13898,13899 @@
13857  13858   
                            <
13858  13859   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13859  13860   
                                as ::aws_smithy_http_server::plugin::Plugin<
13860  13861   
                                    RestJson<L>,
13861  13862   
                                    crate::operation_shape::SparseJsonLists,
13862  13863   
                                    ModelPl::Output
13863  13864   
                                >
13864  13865   
                            >::Output
13865  13866   
                        >,
13866  13867   
13867         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13868         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13868  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13869  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13869  13870   
13870  13871   
                    {
13871  13872   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13872  13873   
        use ::aws_smithy_http_server::plugin::Plugin;
13873  13874   
        let svc = crate::operation_shape::SparseJsonLists::from_handler(handler);
13874  13875   
        let svc = self.model_plugin.apply(svc);
13875  13876   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13876  13877   
            .apply(svc);
13877  13878   
        let svc = self.http_plugin.apply(svc);
13878  13879   
        self.sparse_json_lists_custom(svc)
@@ -13904,13905 +13984,13985 @@
13924  13925   
                            <
13925  13926   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
13926  13927   
                                as ::aws_smithy_http_server::plugin::Plugin<
13927  13928   
                                    RestJson<L>,
13928  13929   
                                    crate::operation_shape::SparseJsonLists,
13929  13930   
                                    ModelPl::Output
13930  13931   
                                >
13931  13932   
                            >::Output
13932  13933   
                        >,
13933  13934   
13934         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
13935         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       13935  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       13936  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
13936  13937   
13937  13938   
                    {
13938  13939   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
13939  13940   
        use ::aws_smithy_http_server::plugin::Plugin;
13940  13941   
        let svc = crate::operation_shape::SparseJsonLists::from_service(service);
13941  13942   
        let svc = self.model_plugin.apply(svc);
13942  13943   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
13943  13944   
            .apply(svc);
13944  13945   
        let svc = self.http_plugin.apply(svc);
13945  13946   
        self.sparse_json_lists_custom(svc)
13946  13947   
    }
13947  13948   
13948  13949   
    /// Sets the [`SparseJsonLists`](crate::operation_shape::SparseJsonLists) to a custom [`Service`](tower::Service).
13949  13950   
    /// not constrained by the Smithy contract.
13950  13951   
    fn sparse_json_lists_custom<S>(mut self, svc: S) -> Self
13951  13952   
    where
13952  13953   
        S: ::tower::Service<
13953         -
                ::http::Request<Body>,
13954         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       13954  +
                ::http_1x::Request<Body>,
       13955  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
13955  13956   
                Error = ::std::convert::Infallible,
13956  13957   
            > + Clone
13957  13958   
            + Send
13958  13959   
            + 'static,
13959  13960   
        S::Future: Send + 'static,
13960  13961   
    {
13961  13962   
        self.sparse_json_lists = Some(::aws_smithy_http_server::routing::Route::new(svc));
13962  13963   
        self
13963  13964   
    }
13964  13965
@@ -13987,13988 +14048,14049 @@
14007  14008   
                            <
14008  14009   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14009  14010   
                                as ::aws_smithy_http_server::plugin::Plugin<
14010  14011   
                                    RestJson<L>,
14011  14012   
                                    crate::operation_shape::SparseJsonMaps,
14012  14013   
                                    ModelPl::Output
14013  14014   
                                >
14014  14015   
                            >::Output
14015  14016   
                        >,
14016  14017   
14017         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14018         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14018  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14019  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14019  14020   
14020  14021   
                    {
14021  14022   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14022  14023   
        use ::aws_smithy_http_server::plugin::Plugin;
14023  14024   
        let svc = crate::operation_shape::SparseJsonMaps::from_handler(handler);
14024  14025   
        let svc = self.model_plugin.apply(svc);
14025  14026   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14026  14027   
            .apply(svc);
14027  14028   
        let svc = self.http_plugin.apply(svc);
14028  14029   
        self.sparse_json_maps_custom(svc)
@@ -14054,14055 +14134,14135 @@
14074  14075   
                            <
14075  14076   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14076  14077   
                                as ::aws_smithy_http_server::plugin::Plugin<
14077  14078   
                                    RestJson<L>,
14078  14079   
                                    crate::operation_shape::SparseJsonMaps,
14079  14080   
                                    ModelPl::Output
14080  14081   
                                >
14081  14082   
                            >::Output
14082  14083   
                        >,
14083  14084   
14084         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14085         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14085  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14086  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14086  14087   
14087  14088   
                    {
14088  14089   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14089  14090   
        use ::aws_smithy_http_server::plugin::Plugin;
14090  14091   
        let svc = crate::operation_shape::SparseJsonMaps::from_service(service);
14091  14092   
        let svc = self.model_plugin.apply(svc);
14092  14093   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14093  14094   
            .apply(svc);
14094  14095   
        let svc = self.http_plugin.apply(svc);
14095  14096   
        self.sparse_json_maps_custom(svc)
14096  14097   
    }
14097  14098   
14098  14099   
    /// Sets the [`SparseJsonMaps`](crate::operation_shape::SparseJsonMaps) to a custom [`Service`](tower::Service).
14099  14100   
    /// not constrained by the Smithy contract.
14100  14101   
    fn sparse_json_maps_custom<S>(mut self, svc: S) -> Self
14101  14102   
    where
14102  14103   
        S: ::tower::Service<
14103         -
                ::http::Request<Body>,
14104         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       14104  +
                ::http_1x::Request<Body>,
       14105  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
14105  14106   
                Error = ::std::convert::Infallible,
14106  14107   
            > + Clone
14107  14108   
            + Send
14108  14109   
            + 'static,
14109  14110   
        S::Future: Send + 'static,
14110  14111   
    {
14111  14112   
        self.sparse_json_maps = Some(::aws_smithy_http_server::routing::Route::new(svc));
14112  14113   
        self
14113  14114   
    }
14114  14115
@@ -14137,14138 +14198,14199 @@
14157  14158   
                            <
14158  14159   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14159  14160   
                                as ::aws_smithy_http_server::plugin::Plugin<
14160  14161   
                                    RestJson<L>,
14161  14162   
                                    crate::operation_shape::StreamingTraits,
14162  14163   
                                    ModelPl::Output
14163  14164   
                                >
14164  14165   
                            >::Output
14165  14166   
                        >,
14166  14167   
14167         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14168         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14168  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14169  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14169  14170   
14170  14171   
                    {
14171  14172   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14172  14173   
        use ::aws_smithy_http_server::plugin::Plugin;
14173  14174   
        let svc = crate::operation_shape::StreamingTraits::from_handler(handler);
14174  14175   
        let svc = self.model_plugin.apply(svc);
14175  14176   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14176  14177   
            .apply(svc);
14177  14178   
        let svc = self.http_plugin.apply(svc);
14178  14179   
        self.streaming_traits_custom(svc)
@@ -14204,14205 +14284,14285 @@
14224  14225   
                            <
14225  14226   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14226  14227   
                                as ::aws_smithy_http_server::plugin::Plugin<
14227  14228   
                                    RestJson<L>,
14228  14229   
                                    crate::operation_shape::StreamingTraits,
14229  14230   
                                    ModelPl::Output
14230  14231   
                                >
14231  14232   
                            >::Output
14232  14233   
                        >,
14233  14234   
14234         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14235         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14235  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14236  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14236  14237   
14237  14238   
                    {
14238  14239   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14239  14240   
        use ::aws_smithy_http_server::plugin::Plugin;
14240  14241   
        let svc = crate::operation_shape::StreamingTraits::from_service(service);
14241  14242   
        let svc = self.model_plugin.apply(svc);
14242  14243   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14243  14244   
            .apply(svc);
14244  14245   
        let svc = self.http_plugin.apply(svc);
14245  14246   
        self.streaming_traits_custom(svc)
14246  14247   
    }
14247  14248   
14248  14249   
    /// Sets the [`StreamingTraits`](crate::operation_shape::StreamingTraits) to a custom [`Service`](tower::Service).
14249  14250   
    /// not constrained by the Smithy contract.
14250  14251   
    fn streaming_traits_custom<S>(mut self, svc: S) -> Self
14251  14252   
    where
14252  14253   
        S: ::tower::Service<
14253         -
                ::http::Request<Body>,
14254         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       14254  +
                ::http_1x::Request<Body>,
       14255  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
14255  14256   
                Error = ::std::convert::Infallible,
14256  14257   
            > + Clone
14257  14258   
            + Send
14258  14259   
            + 'static,
14259  14260   
        S::Future: Send + 'static,
14260  14261   
    {
14261  14262   
        self.streaming_traits = Some(::aws_smithy_http_server::routing::Route::new(svc));
14262  14263   
        self
14263  14264   
    }
14264  14265
@@ -14287,14288 +14348,14349 @@
14307  14308   
                            <
14308  14309   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14309  14310   
                                as ::aws_smithy_http_server::plugin::Plugin<
14310  14311   
                                    RestJson<L>,
14311  14312   
                                    crate::operation_shape::StreamingTraitsRequireLength,
14312  14313   
                                    ModelPl::Output
14313  14314   
                                >
14314  14315   
                            >::Output
14315  14316   
                        >,
14316  14317   
14317         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14318         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14318  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14319  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14319  14320   
14320  14321   
                    {
14321  14322   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14322  14323   
        use ::aws_smithy_http_server::plugin::Plugin;
14323  14324   
        let svc = crate::operation_shape::StreamingTraitsRequireLength::from_handler(handler);
14324  14325   
        let svc = self.model_plugin.apply(svc);
14325  14326   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14326  14327   
            .apply(svc);
14327  14328   
        let svc = self.http_plugin.apply(svc);
14328  14329   
        self.streaming_traits_require_length_custom(svc)
@@ -14354,14355 +14434,14435 @@
14374  14375   
                            <
14375  14376   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14376  14377   
                                as ::aws_smithy_http_server::plugin::Plugin<
14377  14378   
                                    RestJson<L>,
14378  14379   
                                    crate::operation_shape::StreamingTraitsRequireLength,
14379  14380   
                                    ModelPl::Output
14380  14381   
                                >
14381  14382   
                            >::Output
14382  14383   
                        >,
14383  14384   
14384         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14385         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14385  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14386  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14386  14387   
14387  14388   
                    {
14388  14389   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14389  14390   
        use ::aws_smithy_http_server::plugin::Plugin;
14390  14391   
        let svc = crate::operation_shape::StreamingTraitsRequireLength::from_service(service);
14391  14392   
        let svc = self.model_plugin.apply(svc);
14392  14393   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14393  14394   
            .apply(svc);
14394  14395   
        let svc = self.http_plugin.apply(svc);
14395  14396   
        self.streaming_traits_require_length_custom(svc)
14396  14397   
    }
14397  14398   
14398  14399   
    /// Sets the [`StreamingTraitsRequireLength`](crate::operation_shape::StreamingTraitsRequireLength) to a custom [`Service`](tower::Service).
14399  14400   
    /// not constrained by the Smithy contract.
14400  14401   
    fn streaming_traits_require_length_custom<S>(mut self, svc: S) -> Self
14401  14402   
    where
14402  14403   
        S: ::tower::Service<
14403         -
                ::http::Request<Body>,
14404         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       14404  +
                ::http_1x::Request<Body>,
       14405  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
14405  14406   
                Error = ::std::convert::Infallible,
14406  14407   
            > + Clone
14407  14408   
            + Send
14408  14409   
            + 'static,
14409  14410   
        S::Future: Send + 'static,
14410  14411   
    {
14411  14412   
        self.streaming_traits_require_length =
14412  14413   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
14413  14414   
        self
14414  14415   
    }
@@ -14438,14439 +14499,14500 @@
14458  14459   
                            <
14459  14460   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14460  14461   
                                as ::aws_smithy_http_server::plugin::Plugin<
14461  14462   
                                    RestJson<L>,
14462  14463   
                                    crate::operation_shape::StreamingTraitsWithMediaType,
14463  14464   
                                    ModelPl::Output
14464  14465   
                                >
14465  14466   
                            >::Output
14466  14467   
                        >,
14467  14468   
14468         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14469         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14469  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14470  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14470  14471   
14471  14472   
                    {
14472  14473   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14473  14474   
        use ::aws_smithy_http_server::plugin::Plugin;
14474  14475   
        let svc = crate::operation_shape::StreamingTraitsWithMediaType::from_handler(handler);
14475  14476   
        let svc = self.model_plugin.apply(svc);
14476  14477   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14477  14478   
            .apply(svc);
14478  14479   
        let svc = self.http_plugin.apply(svc);
14479  14480   
        self.streaming_traits_with_media_type_custom(svc)
@@ -14505,14506 +14585,14586 @@
14525  14526   
                            <
14526  14527   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14527  14528   
                                as ::aws_smithy_http_server::plugin::Plugin<
14528  14529   
                                    RestJson<L>,
14529  14530   
                                    crate::operation_shape::StreamingTraitsWithMediaType,
14530  14531   
                                    ModelPl::Output
14531  14532   
                                >
14532  14533   
                            >::Output
14533  14534   
                        >,
14534  14535   
14535         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14536         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14536  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14537  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14537  14538   
14538  14539   
                    {
14539  14540   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14540  14541   
        use ::aws_smithy_http_server::plugin::Plugin;
14541  14542   
        let svc = crate::operation_shape::StreamingTraitsWithMediaType::from_service(service);
14542  14543   
        let svc = self.model_plugin.apply(svc);
14543  14544   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14544  14545   
            .apply(svc);
14545  14546   
        let svc = self.http_plugin.apply(svc);
14546  14547   
        self.streaming_traits_with_media_type_custom(svc)
14547  14548   
    }
14548  14549   
14549  14550   
    /// Sets the [`StreamingTraitsWithMediaType`](crate::operation_shape::StreamingTraitsWithMediaType) to a custom [`Service`](tower::Service).
14550  14551   
    /// not constrained by the Smithy contract.
14551  14552   
    fn streaming_traits_with_media_type_custom<S>(mut self, svc: S) -> Self
14552  14553   
    where
14553  14554   
        S: ::tower::Service<
14554         -
                ::http::Request<Body>,
14555         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       14555  +
                ::http_1x::Request<Body>,
       14556  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
14556  14557   
                Error = ::std::convert::Infallible,
14557  14558   
            > + Clone
14558  14559   
            + Send
14559  14560   
            + 'static,
14560  14561   
        S::Future: Send + 'static,
14561  14562   
    {
14562  14563   
        self.streaming_traits_with_media_type =
14563  14564   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
14564  14565   
        self
14565  14566   
    }
@@ -14589,14590 +14650,14651 @@
14609  14610   
                            <
14610  14611   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14611  14612   
                                as ::aws_smithy_http_server::plugin::Plugin<
14612  14613   
                                    RestJson<L>,
14613  14614   
                                    crate::operation_shape::TestBodyStructure,
14614  14615   
                                    ModelPl::Output
14615  14616   
                                >
14616  14617   
                            >::Output
14617  14618   
                        >,
14618  14619   
14619         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14620         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14620  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14621  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14621  14622   
14622  14623   
                    {
14623  14624   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14624  14625   
        use ::aws_smithy_http_server::plugin::Plugin;
14625  14626   
        let svc = crate::operation_shape::TestBodyStructure::from_handler(handler);
14626  14627   
        let svc = self.model_plugin.apply(svc);
14627  14628   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14628  14629   
            .apply(svc);
14629  14630   
        let svc = self.http_plugin.apply(svc);
14630  14631   
        self.test_body_structure_custom(svc)
@@ -14656,14657 +14736,14737 @@
14676  14677   
                            <
14677  14678   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14678  14679   
                                as ::aws_smithy_http_server::plugin::Plugin<
14679  14680   
                                    RestJson<L>,
14680  14681   
                                    crate::operation_shape::TestBodyStructure,
14681  14682   
                                    ModelPl::Output
14682  14683   
                                >
14683  14684   
                            >::Output
14684  14685   
                        >,
14685  14686   
14686         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14687         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14687  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14688  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14688  14689   
14689  14690   
                    {
14690  14691   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14691  14692   
        use ::aws_smithy_http_server::plugin::Plugin;
14692  14693   
        let svc = crate::operation_shape::TestBodyStructure::from_service(service);
14693  14694   
        let svc = self.model_plugin.apply(svc);
14694  14695   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14695  14696   
            .apply(svc);
14696  14697   
        let svc = self.http_plugin.apply(svc);
14697  14698   
        self.test_body_structure_custom(svc)
14698  14699   
    }
14699  14700   
14700  14701   
    /// Sets the [`TestBodyStructure`](crate::operation_shape::TestBodyStructure) to a custom [`Service`](tower::Service).
14701  14702   
    /// not constrained by the Smithy contract.
14702  14703   
    fn test_body_structure_custom<S>(mut self, svc: S) -> Self
14703  14704   
    where
14704  14705   
        S: ::tower::Service<
14705         -
                ::http::Request<Body>,
14706         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       14706  +
                ::http_1x::Request<Body>,
       14707  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
14707  14708   
                Error = ::std::convert::Infallible,
14708  14709   
            > + Clone
14709  14710   
            + Send
14710  14711   
            + 'static,
14711  14712   
        S::Future: Send + 'static,
14712  14713   
    {
14713  14714   
        self.test_body_structure = Some(::aws_smithy_http_server::routing::Route::new(svc));
14714  14715   
        self
14715  14716   
    }
14716  14717
@@ -14739,14740 +14800,14801 @@
14759  14760   
                            <
14760  14761   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14761  14762   
                                as ::aws_smithy_http_server::plugin::Plugin<
14762  14763   
                                    RestJson<L>,
14763  14764   
                                    crate::operation_shape::TestGetNoInputNoPayload,
14764  14765   
                                    ModelPl::Output
14765  14766   
                                >
14766  14767   
                            >::Output
14767  14768   
                        >,
14768  14769   
14769         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14770         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14770  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14771  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14771  14772   
14772  14773   
                    {
14773  14774   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14774  14775   
        use ::aws_smithy_http_server::plugin::Plugin;
14775  14776   
        let svc = crate::operation_shape::TestGetNoInputNoPayload::from_handler(handler);
14776  14777   
        let svc = self.model_plugin.apply(svc);
14777  14778   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14778  14779   
            .apply(svc);
14779  14780   
        let svc = self.http_plugin.apply(svc);
14780  14781   
        self.test_get_no_input_no_payload_custom(svc)
@@ -14806,14807 +14886,14887 @@
14826  14827   
                            <
14827  14828   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14828  14829   
                                as ::aws_smithy_http_server::plugin::Plugin<
14829  14830   
                                    RestJson<L>,
14830  14831   
                                    crate::operation_shape::TestGetNoInputNoPayload,
14831  14832   
                                    ModelPl::Output
14832  14833   
                                >
14833  14834   
                            >::Output
14834  14835   
                        >,
14835  14836   
14836         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14837         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14837  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14838  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14838  14839   
14839  14840   
                    {
14840  14841   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14841  14842   
        use ::aws_smithy_http_server::plugin::Plugin;
14842  14843   
        let svc = crate::operation_shape::TestGetNoInputNoPayload::from_service(service);
14843  14844   
        let svc = self.model_plugin.apply(svc);
14844  14845   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14845  14846   
            .apply(svc);
14846  14847   
        let svc = self.http_plugin.apply(svc);
14847  14848   
        self.test_get_no_input_no_payload_custom(svc)
14848  14849   
    }
14849  14850   
14850  14851   
    /// Sets the [`TestGetNoInputNoPayload`](crate::operation_shape::TestGetNoInputNoPayload) to a custom [`Service`](tower::Service).
14851  14852   
    /// not constrained by the Smithy contract.
14852  14853   
    fn test_get_no_input_no_payload_custom<S>(mut self, svc: S) -> Self
14853  14854   
    where
14854  14855   
        S: ::tower::Service<
14855         -
                ::http::Request<Body>,
14856         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       14856  +
                ::http_1x::Request<Body>,
       14857  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
14857  14858   
                Error = ::std::convert::Infallible,
14858  14859   
            > + Clone
14859  14860   
            + Send
14860  14861   
            + 'static,
14861  14862   
        S::Future: Send + 'static,
14862  14863   
    {
14863  14864   
        self.test_get_no_input_no_payload =
14864  14865   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
14865  14866   
        self
14866  14867   
    }
@@ -14890,14891 +14951,14952 @@
14910  14911   
                            <
14911  14912   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14912  14913   
                                as ::aws_smithy_http_server::plugin::Plugin<
14913  14914   
                                    RestJson<L>,
14914  14915   
                                    crate::operation_shape::TestGetNoPayload,
14915  14916   
                                    ModelPl::Output
14916  14917   
                                >
14917  14918   
                            >::Output
14918  14919   
                        >,
14919  14920   
14920         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14921         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14921  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14922  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14922  14923   
14923  14924   
                    {
14924  14925   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14925  14926   
        use ::aws_smithy_http_server::plugin::Plugin;
14926  14927   
        let svc = crate::operation_shape::TestGetNoPayload::from_handler(handler);
14927  14928   
        let svc = self.model_plugin.apply(svc);
14928  14929   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14929  14930   
            .apply(svc);
14930  14931   
        let svc = self.http_plugin.apply(svc);
14931  14932   
        self.test_get_no_payload_custom(svc)
@@ -14957,14958 +15037,15038 @@
14977  14978   
                            <
14978  14979   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
14979  14980   
                                as ::aws_smithy_http_server::plugin::Plugin<
14980  14981   
                                    RestJson<L>,
14981  14982   
                                    crate::operation_shape::TestGetNoPayload,
14982  14983   
                                    ModelPl::Output
14983  14984   
                                >
14984  14985   
                            >::Output
14985  14986   
                        >,
14986  14987   
14987         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
14988         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       14988  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       14989  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
14989  14990   
14990  14991   
                    {
14991  14992   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
14992  14993   
        use ::aws_smithy_http_server::plugin::Plugin;
14993  14994   
        let svc = crate::operation_shape::TestGetNoPayload::from_service(service);
14994  14995   
        let svc = self.model_plugin.apply(svc);
14995  14996   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
14996  14997   
            .apply(svc);
14997  14998   
        let svc = self.http_plugin.apply(svc);
14998  14999   
        self.test_get_no_payload_custom(svc)
14999  15000   
    }
15000  15001   
15001  15002   
    /// Sets the [`TestGetNoPayload`](crate::operation_shape::TestGetNoPayload) to a custom [`Service`](tower::Service).
15002  15003   
    /// not constrained by the Smithy contract.
15003  15004   
    fn test_get_no_payload_custom<S>(mut self, svc: S) -> Self
15004  15005   
    where
15005  15006   
        S: ::tower::Service<
15006         -
                ::http::Request<Body>,
15007         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15007  +
                ::http_1x::Request<Body>,
       15008  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15008  15009   
                Error = ::std::convert::Infallible,
15009  15010   
            > + Clone
15010  15011   
            + Send
15011  15012   
            + 'static,
15012  15013   
        S::Future: Send + 'static,
15013  15014   
    {
15014  15015   
        self.test_get_no_payload = Some(::aws_smithy_http_server::routing::Route::new(svc));
15015  15016   
        self
15016  15017   
    }
15017  15018
@@ -15040,15041 +15101,15102 @@
15060  15061   
                            <
15061  15062   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15062  15063   
                                as ::aws_smithy_http_server::plugin::Plugin<
15063  15064   
                                    RestJson<L>,
15064  15065   
                                    crate::operation_shape::TestPayloadBlob,
15065  15066   
                                    ModelPl::Output
15066  15067   
                                >
15067  15068   
                            >::Output
15068  15069   
                        >,
15069  15070   
15070         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15071         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15071  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15072  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15072  15073   
15073  15074   
                    {
15074  15075   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15075  15076   
        use ::aws_smithy_http_server::plugin::Plugin;
15076  15077   
        let svc = crate::operation_shape::TestPayloadBlob::from_handler(handler);
15077  15078   
        let svc = self.model_plugin.apply(svc);
15078  15079   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15079  15080   
            .apply(svc);
15080  15081   
        let svc = self.http_plugin.apply(svc);
15081  15082   
        self.test_payload_blob_custom(svc)
@@ -15107,15108 +15187,15188 @@
15127  15128   
                            <
15128  15129   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15129  15130   
                                as ::aws_smithy_http_server::plugin::Plugin<
15130  15131   
                                    RestJson<L>,
15131  15132   
                                    crate::operation_shape::TestPayloadBlob,
15132  15133   
                                    ModelPl::Output
15133  15134   
                                >
15134  15135   
                            >::Output
15135  15136   
                        >,
15136  15137   
15137         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15138         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15138  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15139  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15139  15140   
15140  15141   
                    {
15141  15142   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15142  15143   
        use ::aws_smithy_http_server::plugin::Plugin;
15143  15144   
        let svc = crate::operation_shape::TestPayloadBlob::from_service(service);
15144  15145   
        let svc = self.model_plugin.apply(svc);
15145  15146   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15146  15147   
            .apply(svc);
15147  15148   
        let svc = self.http_plugin.apply(svc);
15148  15149   
        self.test_payload_blob_custom(svc)
15149  15150   
    }
15150  15151   
15151  15152   
    /// Sets the [`TestPayloadBlob`](crate::operation_shape::TestPayloadBlob) to a custom [`Service`](tower::Service).
15152  15153   
    /// not constrained by the Smithy contract.
15153  15154   
    fn test_payload_blob_custom<S>(mut self, svc: S) -> Self
15154  15155   
    where
15155  15156   
        S: ::tower::Service<
15156         -
                ::http::Request<Body>,
15157         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15157  +
                ::http_1x::Request<Body>,
       15158  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15158  15159   
                Error = ::std::convert::Infallible,
15159  15160   
            > + Clone
15160  15161   
            + Send
15161  15162   
            + 'static,
15162  15163   
        S::Future: Send + 'static,
15163  15164   
    {
15164  15165   
        self.test_payload_blob = Some(::aws_smithy_http_server::routing::Route::new(svc));
15165  15166   
        self
15166  15167   
    }
15167  15168
@@ -15190,15191 +15251,15252 @@
15210  15211   
                            <
15211  15212   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15212  15213   
                                as ::aws_smithy_http_server::plugin::Plugin<
15213  15214   
                                    RestJson<L>,
15214  15215   
                                    crate::operation_shape::TestPayloadStructure,
15215  15216   
                                    ModelPl::Output
15216  15217   
                                >
15217  15218   
                            >::Output
15218  15219   
                        >,
15219  15220   
15220         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15221         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15221  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15222  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15222  15223   
15223  15224   
                    {
15224  15225   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15225  15226   
        use ::aws_smithy_http_server::plugin::Plugin;
15226  15227   
        let svc = crate::operation_shape::TestPayloadStructure::from_handler(handler);
15227  15228   
        let svc = self.model_plugin.apply(svc);
15228  15229   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15229  15230   
            .apply(svc);
15230  15231   
        let svc = self.http_plugin.apply(svc);
15231  15232   
        self.test_payload_structure_custom(svc)
@@ -15257,15258 +15337,15338 @@
15277  15278   
                            <
15278  15279   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15279  15280   
                                as ::aws_smithy_http_server::plugin::Plugin<
15280  15281   
                                    RestJson<L>,
15281  15282   
                                    crate::operation_shape::TestPayloadStructure,
15282  15283   
                                    ModelPl::Output
15283  15284   
                                >
15284  15285   
                            >::Output
15285  15286   
                        >,
15286  15287   
15287         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15288         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15288  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15289  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15289  15290   
15290  15291   
                    {
15291  15292   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15292  15293   
        use ::aws_smithy_http_server::plugin::Plugin;
15293  15294   
        let svc = crate::operation_shape::TestPayloadStructure::from_service(service);
15294  15295   
        let svc = self.model_plugin.apply(svc);
15295  15296   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15296  15297   
            .apply(svc);
15297  15298   
        let svc = self.http_plugin.apply(svc);
15298  15299   
        self.test_payload_structure_custom(svc)
15299  15300   
    }
15300  15301   
15301  15302   
    /// Sets the [`TestPayloadStructure`](crate::operation_shape::TestPayloadStructure) to a custom [`Service`](tower::Service).
15302  15303   
    /// not constrained by the Smithy contract.
15303  15304   
    fn test_payload_structure_custom<S>(mut self, svc: S) -> Self
15304  15305   
    where
15305  15306   
        S: ::tower::Service<
15306         -
                ::http::Request<Body>,
15307         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15307  +
                ::http_1x::Request<Body>,
       15308  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15308  15309   
                Error = ::std::convert::Infallible,
15309  15310   
            > + Clone
15310  15311   
            + Send
15311  15312   
            + 'static,
15312  15313   
        S::Future: Send + 'static,
15313  15314   
    {
15314  15315   
        self.test_payload_structure = Some(::aws_smithy_http_server::routing::Route::new(svc));
15315  15316   
        self
15316  15317   
    }
15317  15318
@@ -15340,15341 +15401,15402 @@
15360  15361   
                            <
15361  15362   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15362  15363   
                                as ::aws_smithy_http_server::plugin::Plugin<
15363  15364   
                                    RestJson<L>,
15364  15365   
                                    crate::operation_shape::TestPostNoInputNoPayload,
15365  15366   
                                    ModelPl::Output
15366  15367   
                                >
15367  15368   
                            >::Output
15368  15369   
                        >,
15369  15370   
15370         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15371         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15371  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15372  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15372  15373   
15373  15374   
                    {
15374  15375   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15375  15376   
        use ::aws_smithy_http_server::plugin::Plugin;
15376  15377   
        let svc = crate::operation_shape::TestPostNoInputNoPayload::from_handler(handler);
15377  15378   
        let svc = self.model_plugin.apply(svc);
15378  15379   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15379  15380   
            .apply(svc);
15380  15381   
        let svc = self.http_plugin.apply(svc);
15381  15382   
        self.test_post_no_input_no_payload_custom(svc)
@@ -15407,15408 +15487,15488 @@
15427  15428   
                            <
15428  15429   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15429  15430   
                                as ::aws_smithy_http_server::plugin::Plugin<
15430  15431   
                                    RestJson<L>,
15431  15432   
                                    crate::operation_shape::TestPostNoInputNoPayload,
15432  15433   
                                    ModelPl::Output
15433  15434   
                                >
15434  15435   
                            >::Output
15435  15436   
                        >,
15436  15437   
15437         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15438         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15438  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15439  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15439  15440   
15440  15441   
                    {
15441  15442   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15442  15443   
        use ::aws_smithy_http_server::plugin::Plugin;
15443  15444   
        let svc = crate::operation_shape::TestPostNoInputNoPayload::from_service(service);
15444  15445   
        let svc = self.model_plugin.apply(svc);
15445  15446   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15446  15447   
            .apply(svc);
15447  15448   
        let svc = self.http_plugin.apply(svc);
15448  15449   
        self.test_post_no_input_no_payload_custom(svc)
15449  15450   
    }
15450  15451   
15451  15452   
    /// Sets the [`TestPostNoInputNoPayload`](crate::operation_shape::TestPostNoInputNoPayload) to a custom [`Service`](tower::Service).
15452  15453   
    /// not constrained by the Smithy contract.
15453  15454   
    fn test_post_no_input_no_payload_custom<S>(mut self, svc: S) -> Self
15454  15455   
    where
15455  15456   
        S: ::tower::Service<
15456         -
                ::http::Request<Body>,
15457         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15457  +
                ::http_1x::Request<Body>,
       15458  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15458  15459   
                Error = ::std::convert::Infallible,
15459  15460   
            > + Clone
15460  15461   
            + Send
15461  15462   
            + 'static,
15462  15463   
        S::Future: Send + 'static,
15463  15464   
    {
15464  15465   
        self.test_post_no_input_no_payload =
15465  15466   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
15466  15467   
        self
15467  15468   
    }
@@ -15491,15492 +15552,15553 @@
15511  15512   
                            <
15512  15513   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15513  15514   
                                as ::aws_smithy_http_server::plugin::Plugin<
15514  15515   
                                    RestJson<L>,
15515  15516   
                                    crate::operation_shape::TestPostNoPayload,
15516  15517   
                                    ModelPl::Output
15517  15518   
                                >
15518  15519   
                            >::Output
15519  15520   
                        >,
15520  15521   
15521         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15522         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15522  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15523  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15523  15524   
15524  15525   
                    {
15525  15526   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15526  15527   
        use ::aws_smithy_http_server::plugin::Plugin;
15527  15528   
        let svc = crate::operation_shape::TestPostNoPayload::from_handler(handler);
15528  15529   
        let svc = self.model_plugin.apply(svc);
15529  15530   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15530  15531   
            .apply(svc);
15531  15532   
        let svc = self.http_plugin.apply(svc);
15532  15533   
        self.test_post_no_payload_custom(svc)
@@ -15558,15559 +15638,15639 @@
15578  15579   
                            <
15579  15580   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15580  15581   
                                as ::aws_smithy_http_server::plugin::Plugin<
15581  15582   
                                    RestJson<L>,
15582  15583   
                                    crate::operation_shape::TestPostNoPayload,
15583  15584   
                                    ModelPl::Output
15584  15585   
                                >
15585  15586   
                            >::Output
15586  15587   
                        >,
15587  15588   
15588         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15589         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15589  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15590  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15590  15591   
15591  15592   
                    {
15592  15593   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15593  15594   
        use ::aws_smithy_http_server::plugin::Plugin;
15594  15595   
        let svc = crate::operation_shape::TestPostNoPayload::from_service(service);
15595  15596   
        let svc = self.model_plugin.apply(svc);
15596  15597   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15597  15598   
            .apply(svc);
15598  15599   
        let svc = self.http_plugin.apply(svc);
15599  15600   
        self.test_post_no_payload_custom(svc)
15600  15601   
    }
15601  15602   
15602  15603   
    /// Sets the [`TestPostNoPayload`](crate::operation_shape::TestPostNoPayload) to a custom [`Service`](tower::Service).
15603  15604   
    /// not constrained by the Smithy contract.
15604  15605   
    fn test_post_no_payload_custom<S>(mut self, svc: S) -> Self
15605  15606   
    where
15606  15607   
        S: ::tower::Service<
15607         -
                ::http::Request<Body>,
15608         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15608  +
                ::http_1x::Request<Body>,
       15609  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15609  15610   
                Error = ::std::convert::Infallible,
15610  15611   
            > + Clone
15611  15612   
            + Send
15612  15613   
            + 'static,
15613  15614   
        S::Future: Send + 'static,
15614  15615   
    {
15615  15616   
        self.test_post_no_payload = Some(::aws_smithy_http_server::routing::Route::new(svc));
15616  15617   
        self
15617  15618   
    }
15618  15619
@@ -15641,15642 +15702,15703 @@
15661  15662   
                            <
15662  15663   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15663  15664   
                                as ::aws_smithy_http_server::plugin::Plugin<
15664  15665   
                                    RestJson<L>,
15665  15666   
                                    crate::operation_shape::TimestampFormatHeaders,
15666  15667   
                                    ModelPl::Output
15667  15668   
                                >
15668  15669   
                            >::Output
15669  15670   
                        >,
15670  15671   
15671         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15672         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15672  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15673  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15673  15674   
15674  15675   
                    {
15675  15676   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15676  15677   
        use ::aws_smithy_http_server::plugin::Plugin;
15677  15678   
        let svc = crate::operation_shape::TimestampFormatHeaders::from_handler(handler);
15678  15679   
        let svc = self.model_plugin.apply(svc);
15679  15680   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15680  15681   
            .apply(svc);
15681  15682   
        let svc = self.http_plugin.apply(svc);
15682  15683   
        self.timestamp_format_headers_custom(svc)
@@ -15708,15709 +15788,15789 @@
15728  15729   
                            <
15729  15730   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15730  15731   
                                as ::aws_smithy_http_server::plugin::Plugin<
15731  15732   
                                    RestJson<L>,
15732  15733   
                                    crate::operation_shape::TimestampFormatHeaders,
15733  15734   
                                    ModelPl::Output
15734  15735   
                                >
15735  15736   
                            >::Output
15736  15737   
                        >,
15737  15738   
15738         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15739         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15739  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15740  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15740  15741   
15741  15742   
                    {
15742  15743   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15743  15744   
        use ::aws_smithy_http_server::plugin::Plugin;
15744  15745   
        let svc = crate::operation_shape::TimestampFormatHeaders::from_service(service);
15745  15746   
        let svc = self.model_plugin.apply(svc);
15746  15747   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15747  15748   
            .apply(svc);
15748  15749   
        let svc = self.http_plugin.apply(svc);
15749  15750   
        self.timestamp_format_headers_custom(svc)
15750  15751   
    }
15751  15752   
15752  15753   
    /// Sets the [`TimestampFormatHeaders`](crate::operation_shape::TimestampFormatHeaders) to a custom [`Service`](tower::Service).
15753  15754   
    /// not constrained by the Smithy contract.
15754  15755   
    fn timestamp_format_headers_custom<S>(mut self, svc: S) -> Self
15755  15756   
    where
15756  15757   
        S: ::tower::Service<
15757         -
                ::http::Request<Body>,
15758         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15758  +
                ::http_1x::Request<Body>,
       15759  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15759  15760   
                Error = ::std::convert::Infallible,
15760  15761   
            > + Clone
15761  15762   
            + Send
15762  15763   
            + 'static,
15763  15764   
        S::Future: Send + 'static,
15764  15765   
    {
15765  15766   
        self.timestamp_format_headers = Some(::aws_smithy_http_server::routing::Route::new(svc));
15766  15767   
        self
15767  15768   
    }
15768  15769
@@ -15791,15792 +15852,15853 @@
15811  15812   
                            <
15812  15813   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15813  15814   
                                as ::aws_smithy_http_server::plugin::Plugin<
15814  15815   
                                    RestJson<L>,
15815  15816   
                                    crate::operation_shape::UnitInputAndOutput,
15816  15817   
                                    ModelPl::Output
15817  15818   
                                >
15818  15819   
                            >::Output
15819  15820   
                        >,
15820  15821   
15821         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15822         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15822  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15823  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15823  15824   
15824  15825   
                    {
15825  15826   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15826  15827   
        use ::aws_smithy_http_server::plugin::Plugin;
15827  15828   
        let svc = crate::operation_shape::UnitInputAndOutput::from_handler(handler);
15828  15829   
        let svc = self.model_plugin.apply(svc);
15829  15830   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15830  15831   
            .apply(svc);
15831  15832   
        let svc = self.http_plugin.apply(svc);
15832  15833   
        self.unit_input_and_output_custom(svc)
@@ -15858,15859 +15938,15939 @@
15878  15879   
                            <
15879  15880   
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
15880  15881   
                                as ::aws_smithy_http_server::plugin::Plugin<
15881  15882   
                                    RestJson<L>,
15882  15883   
                                    crate::operation_shape::UnitInputAndOutput,
15883  15884   
                                    ModelPl::Output
15884  15885   
                                >
15885  15886   
                            >::Output
15886  15887   
                        >,
15887  15888   
15888         -
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
15889         -
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
       15889  +
                        HttpPl::Output: ::tower::Service<::http_1x::Request<Body>, Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
       15890  +
                        <HttpPl::Output as ::tower::Service<::http_1x::Request<Body>>>::Future: Send + 'static,
15890  15891   
15891  15892   
                    {
15892  15893   
        use ::aws_smithy_http_server::operation::OperationShapeExt;
15893  15894   
        use ::aws_smithy_http_server::plugin::Plugin;
15894  15895   
        let svc = crate::operation_shape::UnitInputAndOutput::from_service(service);
15895  15896   
        let svc = self.model_plugin.apply(svc);
15896  15897   
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
15897  15898   
            .apply(svc);
15898  15899   
        let svc = self.http_plugin.apply(svc);
15899  15900   
        self.unit_input_and_output_custom(svc)
15900  15901   
    }
15901  15902   
15902  15903   
    /// Sets the [`UnitInputAndOutput`](crate::operation_shape::UnitInputAndOutput) to a custom [`Service`](tower::Service).
15903  15904   
    /// not constrained by the Smithy contract.
15904  15905   
    fn unit_input_and_output_custom<S>(mut self, svc: S) -> Self
15905  15906   
    where
15906  15907   
        S: ::tower::Service<
15907         -
                ::http::Request<Body>,
15908         -
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       15908  +
                ::http_1x::Request<Body>,
       15909  +
                Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
15909  15910   
                Error = ::std::convert::Infallible,
15910  15911   
            > + Clone
15911  15912   
            + Send
15912  15913   
            + 'static,
15913  15914   
        S::Future: Send + 'static,
15914  15915   
    {
15915  15916   
        self.unit_input_and_output = Some(::aws_smithy_http_server::routing::Route::new(svc));
15916  15917   
        self
15917  15918   
    }
15918  15919   
}
@@ -18026,18027 +19672,19673 @@
18046  18047   
        Ok(())
18047  18048   
    }
18048  18049   
}
18049  18050   
18050  18051   
impl std::error::Error for MissingOperationsError {}
18051  18052   
18052  18053   
mod request_specs {
18053  18054   
    pub(super) fn all_query_string_types(
18054  18055   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18055  18056   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18056         -
                    ::http::Method::GET,
       18057  +
                    ::http_1x::Method::GET,
18057  18058   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18058  18059   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18059  18060   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18060  18061   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("AllQueryStringTypesInput")),
18061  18062   
]),
18062  18063   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18063  18064   
])
18064  18065   
                        )
18065  18066   
                    ),
18066  18067   
                )
18067  18068   
    }
18068  18069   
    pub(super) fn constant_and_variable_query_string(
18069  18070   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18070  18071   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18071         -
                    ::http::Method::GET,
       18072  +
                    ::http_1x::Method::GET,
18072  18073   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18073  18074   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18074  18075   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18075  18076   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("ConstantAndVariableQueryString")),
18076  18077   
]),
18077  18078   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18078  18079   
    ::aws_smithy_http_server::routing::request_spec::QuerySegment::KeyValue(String::from("foo"), String::from("bar")),
18079  18080   
])
18080  18081   
                        )
18081  18082   
                    ),
18082  18083   
                )
18083  18084   
    }
18084  18085   
    pub(super) fn constant_query_string(
18085  18086   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18086  18087   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18087         -
                    ::http::Method::GET,
       18088  +
                    ::http_1x::Method::GET,
18088  18089   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18089  18090   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18090  18091   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18091  18092   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("ConstantQueryString")),
18092  18093   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18093  18094   
]),
18094  18095   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18095  18096   
    ::aws_smithy_http_server::routing::request_spec::QuerySegment::KeyValue(String::from("foo"), String::from("bar")),
18096  18097   
    ::aws_smithy_http_server::routing::request_spec::QuerySegment::Key(String::from("hello")),
18097  18098   
])
18098  18099   
                        )
18099  18100   
                    ),
18100  18101   
                )
18101  18102   
    }
18102  18103   
    pub(super) fn content_type_parameters(
18103  18104   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18104  18105   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18105         -
                    ::http::Method::POST,
       18106  +
                    ::http_1x::Method::POST,
18106  18107   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18107  18108   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18108  18109   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18109  18110   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("ContentTypeParameters")),
18110  18111   
]),
18111  18112   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18112  18113   
])
18113  18114   
                        )
18114  18115   
                    ),
18115  18116   
                )
18116  18117   
    }
18117  18118   
    pub(super) fn datetime_offsets() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18118  18119   
    {
18119  18120   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18120         -
                    ::http::Method::POST,
       18121  +
                    ::http_1x::Method::POST,
18121  18122   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18122  18123   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18123  18124   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18124  18125   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("DatetimeOffsets")),
18125  18126   
]),
18126  18127   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18127  18128   
])
18128  18129   
                        )
18129  18130   
                    ),
18130  18131   
                )
18131  18132   
    }
18132  18133   
    pub(super) fn document_type() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18133  18134   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18134         -
                    ::http::Method::PUT,
       18135  +
                    ::http_1x::Method::PUT,
18135  18136   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18136  18137   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18137  18138   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18138  18139   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("DocumentType")),
18139  18140   
]),
18140  18141   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18141  18142   
])
18142  18143   
                        )
18143  18144   
                    ),
18144  18145   
                )
18145  18146   
    }
18146  18147   
    pub(super) fn document_type_as_map_value(
18147  18148   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18148  18149   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18149         -
                    ::http::Method::PUT,
       18150  +
                    ::http_1x::Method::PUT,
18150  18151   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18151  18152   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18152  18153   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18153  18154   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("DocumentTypeAsMapValue")),
18154  18155   
]),
18155  18156   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18156  18157   
])
18157  18158   
                        )
18158  18159   
                    ),
18159  18160   
                )
18160  18161   
    }
18161  18162   
    pub(super) fn document_type_as_payload(
18162  18163   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18163  18164   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18164         -
                    ::http::Method::PUT,
       18165  +
                    ::http_1x::Method::PUT,
18165  18166   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18166  18167   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18167  18168   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18168  18169   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("DocumentTypeAsPayload")),
18169  18170   
]),
18170  18171   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18171  18172   
])
18172  18173   
                        )
18173  18174   
                    ),
18174  18175   
                )
18175  18176   
    }
18176  18177   
    pub(super) fn empty_input_and_empty_output(
18177  18178   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18178  18179   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18179         -
                    ::http::Method::POST,
       18180  +
                    ::http_1x::Method::POST,
18180  18181   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18181  18182   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18182  18183   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18183  18184   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("EmptyInputAndEmptyOutput")),
18184  18185   
]),
18185  18186   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18186  18187   
])
18187  18188   
                        )
18188  18189   
                    ),
18189  18190   
                )
18190  18191   
    }
18191  18192   
    pub(super) fn endpoint_operation(
18192  18193   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18193  18194   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18194         -
                    ::http::Method::POST,
       18195  +
                    ::http_1x::Method::POST,
18195  18196   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18196  18197   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18197  18198   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18198  18199   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("EndpointOperation")),
18199  18200   
]),
18200  18201   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18201  18202   
])
18202  18203   
                        )
18203  18204   
                    ),
18204  18205   
                )
18205  18206   
    }
18206  18207   
    pub(super) fn endpoint_with_host_label_operation(
18207  18208   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18208  18209   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18209         -
                    ::http::Method::POST,
       18210  +
                    ::http_1x::Method::POST,
18210  18211   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18211  18212   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18212  18213   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18213  18214   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("EndpointWithHostLabelOperation")),
18214  18215   
]),
18215  18216   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18216  18217   
])
18217  18218   
                        )
18218  18219   
                    ),
18219  18220   
                )
18220  18221   
    }
18221  18222   
    pub(super) fn fractional_seconds(
18222  18223   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18223  18224   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18224         -
                    ::http::Method::POST,
       18225  +
                    ::http_1x::Method::POST,
18225  18226   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18226  18227   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18227  18228   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18228  18229   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("FractionalSeconds")),
18229  18230   
]),
18230  18231   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18231  18232   
])
18232  18233   
                        )
18233  18234   
                    ),
18234  18235   
                )
18235  18236   
    }
18236  18237   
    pub(super) fn greeting_with_errors(
18237  18238   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18238  18239   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18239         -
                    ::http::Method::PUT,
       18240  +
                    ::http_1x::Method::PUT,
18240  18241   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18241  18242   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18242  18243   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18243  18244   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("GreetingWithErrors")),
18244  18245   
]),
18245  18246   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18246  18247   
])
18247  18248   
                        )
18248  18249   
                    ),
18249  18250   
                )
18250  18251   
    }
18251  18252   
    pub(super) fn host_with_path_operation(
18252  18253   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18253  18254   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18254         -
                    ::http::Method::GET,
       18255  +
                    ::http_1x::Method::GET,
18255  18256   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18256  18257   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18257  18258   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18258  18259   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HostWithPathOperation")),
18259  18260   
]),
18260  18261   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18261  18262   
])
18262  18263   
                        )
18263  18264   
                    ),
18264  18265   
                )
18265  18266   
    }
18266  18267   
    pub(super) fn http_checksum_required(
18267  18268   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18268  18269   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18269         -
                    ::http::Method::POST,
       18270  +
                    ::http_1x::Method::POST,
18270  18271   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18271  18272   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18272  18273   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18273  18274   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpChecksumRequired")),
18274  18275   
]),
18275  18276   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18276  18277   
])
18277  18278   
                        )
18278  18279   
                    ),
18279  18280   
                )
18280  18281   
    }
18281  18282   
    pub(super) fn http_empty_prefix_headers(
18282  18283   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18283  18284   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18284         -
                    ::http::Method::GET,
       18285  +
                    ::http_1x::Method::GET,
18285  18286   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18286  18287   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18287  18288   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18288  18289   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpEmptyPrefixHeaders")),
18289  18290   
]),
18290  18291   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18291  18292   
])
18292  18293   
                        )
18293  18294   
                    ),
18294  18295   
                )
18295  18296   
    }
18296  18297   
    pub(super) fn http_enum_payload() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18297  18298   
    {
18298  18299   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18299         -
                    ::http::Method::POST,
       18300  +
                    ::http_1x::Method::POST,
18300  18301   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18301  18302   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18302  18303   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18303  18304   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("EnumPayload")),
18304  18305   
]),
18305  18306   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18306  18307   
])
18307  18308   
                        )
18308  18309   
                    ),
18309  18310   
                )
18310  18311   
    }
18311  18312   
    pub(super) fn http_payload_traits(
18312  18313   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18313  18314   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18314         -
                    ::http::Method::POST,
       18315  +
                    ::http_1x::Method::POST,
18315  18316   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18316  18317   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18317  18318   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18318  18319   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpPayloadTraits")),
18319  18320   
]),
18320  18321   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18321  18322   
])
18322  18323   
                        )
18323  18324   
                    ),
18324  18325   
                )
18325  18326   
    }
18326  18327   
    pub(super) fn http_payload_traits_with_media_type(
18327  18328   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18328  18329   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18329         -
                    ::http::Method::POST,
       18330  +
                    ::http_1x::Method::POST,
18330  18331   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18331  18332   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18332  18333   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18333  18334   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpPayloadTraitsWithMediaType")),
18334  18335   
]),
18335  18336   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18336  18337   
])
18337  18338   
                        )
18338  18339   
                    ),
18339  18340   
                )
18340  18341   
    }
18341  18342   
    pub(super) fn http_payload_with_structure(
18342  18343   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18343  18344   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18344         -
                    ::http::Method::PUT,
       18345  +
                    ::http_1x::Method::PUT,
18345  18346   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18346  18347   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18347  18348   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18348  18349   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpPayloadWithStructure")),
18349  18350   
]),
18350  18351   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18351  18352   
])
18352  18353   
                        )
18353  18354   
                    ),
18354  18355   
                )
18355  18356   
    }
18356  18357   
    pub(super) fn http_payload_with_union(
18357  18358   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18358  18359   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18359         -
                    ::http::Method::PUT,
       18360  +
                    ::http_1x::Method::PUT,
18360  18361   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18361  18362   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18362  18363   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18363  18364   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpPayloadWithUnion")),
18364  18365   
]),
18365  18366   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18366  18367   
])
18367  18368   
                        )
18368  18369   
                    ),
18369  18370   
                )
18370  18371   
    }
18371  18372   
    pub(super) fn http_prefix_headers(
18372  18373   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18373  18374   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18374         -
                    ::http::Method::GET,
       18375  +
                    ::http_1x::Method::GET,
18375  18376   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18376  18377   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18377  18378   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18378  18379   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpPrefixHeaders")),
18379  18380   
]),
18380  18381   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18381  18382   
])
18382  18383   
                        )
18383  18384   
                    ),
18384  18385   
                )
18385  18386   
    }
18386  18387   
    pub(super) fn http_prefix_headers_in_response(
18387  18388   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18388  18389   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18389         -
                    ::http::Method::GET,
       18390  +
                    ::http_1x::Method::GET,
18390  18391   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18391  18392   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18392  18393   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18393  18394   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpPrefixHeadersResponse")),
18394  18395   
]),
18395  18396   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18396  18397   
])
18397  18398   
                        )
18398  18399   
                    ),
18399  18400   
                )
18400  18401   
    }
18401  18402   
    pub(super) fn http_request_with_float_labels(
18402  18403   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18403  18404   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18404         -
                    ::http::Method::GET,
       18405  +
                    ::http_1x::Method::GET,
18405  18406   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18406  18407   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18407  18408   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18408  18409   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("FloatHttpLabels")),
18409  18410   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18410  18411   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18411  18412   
]),
18412  18413   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18413  18414   
])
18414  18415   
                        )
18415  18416   
                    ),
18416  18417   
                )
18417  18418   
    }
18418  18419   
    pub(super) fn http_request_with_greedy_label_in_path(
18419  18420   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18420  18421   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18421         -
                    ::http::Method::GET,
       18422  +
                    ::http_1x::Method::GET,
18422  18423   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18423  18424   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18424  18425   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18425  18426   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpRequestWithGreedyLabelInPath")),
18426  18427   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("foo")),
18427  18428   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18428  18429   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("baz")),
18429  18430   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Greedy,
18430  18431   
]),
18431  18432   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18432  18433   
])
18433  18434   
                        )
18434  18435   
                    ),
18435  18436   
                )
18436  18437   
    }
18437  18438   
    pub(super) fn http_request_with_labels(
18438  18439   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18439  18440   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18440         -
                    ::http::Method::GET,
       18441  +
                    ::http_1x::Method::GET,
18441  18442   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18442  18443   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18443  18444   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18444  18445   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpRequestWithLabels")),
18445  18446   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18446  18447   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18447  18448   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18448  18449   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18449  18450   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18450  18451   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18451  18452   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18452  18453   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18453  18454   
]),
18454  18455   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18455  18456   
])
18456  18457   
                        )
18457  18458   
                    ),
18458  18459   
                )
18459  18460   
    }
18460  18461   
    pub(super) fn http_request_with_labels_and_timestamp_format(
18461  18462   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18462  18463   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18463         -
                    ::http::Method::GET,
       18464  +
                    ::http_1x::Method::GET,
18464  18465   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18465  18466   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18466  18467   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18467  18468   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpRequestWithLabelsAndTimestampFormat")),
18468  18469   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18469  18470   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18470  18471   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18471  18472   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18472  18473   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18473  18474   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18474  18475   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18475  18476   
]),
18476  18477   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18477  18478   
])
18478  18479   
                        )
18479  18480   
                    ),
18480  18481   
                )
18481  18482   
    }
18482  18483   
    pub(super) fn http_request_with_regex_literal(
18483  18484   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18484  18485   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18485         -
                    ::http::Method::GET,
       18486  +
                    ::http_1x::Method::GET,
18486  18487   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18487  18488   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18488  18489   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18489  18490   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("ReDosLiteral")),
18490  18491   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18491  18492   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("(a+)+")),
18492  18493   
]),
18493  18494   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18494  18495   
])
18495  18496   
                        )
18496  18497   
                    ),
18497  18498   
                )
18498  18499   
    }
18499  18500   
    pub(super) fn http_response_code(
18500  18501   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18501  18502   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18502         -
                    ::http::Method::PUT,
       18503  +
                    ::http_1x::Method::PUT,
18503  18504   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18504  18505   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18505  18506   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18506  18507   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("HttpResponseCode")),
18507  18508   
]),
18508  18509   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18509  18510   
])
18510  18511   
                        )
18511  18512   
                    ),
18512  18513   
                )
18513  18514   
    }
18514  18515   
    pub(super) fn http_string_payload(
18515  18516   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18516  18517   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18517         -
                    ::http::Method::POST,
       18518  +
                    ::http_1x::Method::POST,
18518  18519   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18519  18520   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18520  18521   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18521  18522   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("StringPayload")),
18522  18523   
]),
18523  18524   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18524  18525   
])
18525  18526   
                        )
18526  18527   
                    ),
18527  18528   
                )
18528  18529   
    }
18529  18530   
    pub(super) fn ignore_query_params_in_response(
18530  18531   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18531  18532   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18532         -
                    ::http::Method::GET,
       18533  +
                    ::http_1x::Method::GET,
18533  18534   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18534  18535   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18535  18536   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18536  18537   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("IgnoreQueryParamsInResponse")),
18537  18538   
]),
18538  18539   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18539  18540   
])
18540  18541   
                        )
18541  18542   
                    ),
18542  18543   
                )
18543  18544   
    }
18544  18545   
    pub(super) fn input_and_output_with_headers(
18545  18546   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18546  18547   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18547         -
                    ::http::Method::POST,
       18548  +
                    ::http_1x::Method::POST,
18548  18549   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18549  18550   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18550  18551   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18551  18552   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("InputAndOutputWithHeaders")),
18552  18553   
]),
18553  18554   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18554  18555   
])
18555  18556   
                        )
18556  18557   
                    ),
18557  18558   
                )
18558  18559   
    }
18559  18560   
    pub(super) fn json_blobs() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18560  18561   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18561         -
                    ::http::Method::POST,
       18562  +
                    ::http_1x::Method::POST,
18562  18563   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18563  18564   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18564  18565   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18565  18566   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonBlobs")),
18566  18567   
]),
18567  18568   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18568  18569   
])
18569  18570   
                        )
18570  18571   
                    ),
18571  18572   
                )
18572  18573   
    }
18573  18574   
    pub(super) fn json_enums() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18574  18575   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18575         -
                    ::http::Method::PUT,
       18576  +
                    ::http_1x::Method::PUT,
18576  18577   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18577  18578   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18578  18579   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18579  18580   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonEnums")),
18580  18581   
]),
18581  18582   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18582  18583   
])
18583  18584   
                        )
18584  18585   
                    ),
18585  18586   
                )
18586  18587   
    }
18587  18588   
    pub(super) fn json_int_enums() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18588  18589   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18589         -
                    ::http::Method::PUT,
       18590  +
                    ::http_1x::Method::PUT,
18590  18591   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18591  18592   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18592  18593   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18593  18594   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonIntEnums")),
18594  18595   
]),
18595  18596   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18596  18597   
])
18597  18598   
                        )
18598  18599   
                    ),
18599  18600   
                )
18600  18601   
    }
18601  18602   
    pub(super) fn json_lists() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18602  18603   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18603         -
                    ::http::Method::PUT,
       18604  +
                    ::http_1x::Method::PUT,
18604  18605   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18605  18606   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18606  18607   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18607  18608   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonLists")),
18608  18609   
]),
18609  18610   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18610  18611   
])
18611  18612   
                        )
18612  18613   
                    ),
18613  18614   
                )
18614  18615   
    }
18615  18616   
    pub(super) fn json_maps() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18616  18617   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18617         -
                    ::http::Method::POST,
       18618  +
                    ::http_1x::Method::POST,
18618  18619   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18619  18620   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18620  18621   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18621  18622   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonMaps")),
18622  18623   
]),
18623  18624   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18624  18625   
])
18625  18626   
                        )
18626  18627   
                    ),
18627  18628   
                )
18628  18629   
    }
18629  18630   
    pub(super) fn json_timestamps() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18630  18631   
    {
18631  18632   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18632         -
                    ::http::Method::POST,
       18633  +
                    ::http_1x::Method::POST,
18633  18634   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18634  18635   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18635  18636   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18636  18637   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonTimestamps")),
18637  18638   
]),
18638  18639   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18639  18640   
])
18640  18641   
                        )
18641  18642   
                    ),
18642  18643   
                )
18643  18644   
    }
18644  18645   
    pub(super) fn json_unions() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18645  18646   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18646         -
                    ::http::Method::PUT,
       18647  +
                    ::http_1x::Method::PUT,
18647  18648   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18648  18649   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18649  18650   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18650  18651   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("JsonUnions")),
18651  18652   
]),
18652  18653   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18653  18654   
])
18654  18655   
                        )
18655  18656   
                    ),
18656  18657   
                )
18657  18658   
    }
18658  18659   
    pub(super) fn malformed_accept_with_body(
18659  18660   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18660  18661   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18661         -
                    ::http::Method::POST,
       18662  +
                    ::http_1x::Method::POST,
18662  18663   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18663  18664   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18664  18665   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18665  18666   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedAcceptWithBody")),
18666  18667   
]),
18667  18668   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18668  18669   
])
18669  18670   
                        )
18670  18671   
                    ),
18671  18672   
                )
18672  18673   
    }
18673  18674   
    pub(super) fn malformed_accept_with_generic_string(
18674  18675   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18675  18676   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18676         -
                    ::http::Method::POST,
       18677  +
                    ::http_1x::Method::POST,
18677  18678   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18678  18679   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18679  18680   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18680  18681   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedAcceptWithGenericString")),
18681  18682   
]),
18682  18683   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18683  18684   
])
18684  18685   
                        )
18685  18686   
                    ),
18686  18687   
                )
18687  18688   
    }
18688  18689   
    pub(super) fn malformed_accept_with_payload(
18689  18690   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18690  18691   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18691         -
                    ::http::Method::POST,
       18692  +
                    ::http_1x::Method::POST,
18692  18693   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18693  18694   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18694  18695   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18695  18696   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedAcceptWithPayload")),
18696  18697   
]),
18697  18698   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18698  18699   
])
18699  18700   
                        )
18700  18701   
                    ),
18701  18702   
                )
18702  18703   
    }
18703  18704   
    pub(super) fn malformed_blob() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18704  18705   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18705         -
                    ::http::Method::POST,
       18706  +
                    ::http_1x::Method::POST,
18706  18707   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18707  18708   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18708  18709   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18709  18710   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedBlob")),
18710  18711   
]),
18711  18712   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18712  18713   
])
18713  18714   
                        )
18714  18715   
                    ),
18715  18716   
                )
18716  18717   
    }
18717  18718   
    pub(super) fn malformed_boolean() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18718  18719   
    {
18719  18720   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18720         -
                    ::http::Method::POST,
       18721  +
                    ::http_1x::Method::POST,
18721  18722   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18722  18723   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18723  18724   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18724  18725   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedBoolean")),
18725  18726   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18726  18727   
]),
18727  18728   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18728  18729   
])
18729  18730   
                        )
18730  18731   
                    ),
18731  18732   
                )
18732  18733   
    }
18733  18734   
    pub(super) fn malformed_byte() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18734  18735   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18735         -
                    ::http::Method::POST,
       18736  +
                    ::http_1x::Method::POST,
18736  18737   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18737  18738   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18738  18739   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18739  18740   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedByte")),
18740  18741   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18741  18742   
]),
18742  18743   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18743  18744   
])
18744  18745   
                        )
18745  18746   
                    ),
18746  18747   
                )
18747  18748   
    }
18748  18749   
    pub(super) fn malformed_content_type_with_body(
18749  18750   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18750  18751   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18751         -
                    ::http::Method::POST,
       18752  +
                    ::http_1x::Method::POST,
18752  18753   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18753  18754   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18754  18755   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18755  18756   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedContentTypeWithBody")),
18756  18757   
]),
18757  18758   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18758  18759   
])
18759  18760   
                        )
18760  18761   
                    ),
18761  18762   
                )
18762  18763   
    }
18763  18764   
    pub(super) fn malformed_content_type_with_generic_string(
18764  18765   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18765  18766   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18766         -
                    ::http::Method::POST,
       18767  +
                    ::http_1x::Method::POST,
18767  18768   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18768  18769   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18769  18770   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18770  18771   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedContentTypeWithGenericString")),
18771  18772   
]),
18772  18773   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18773  18774   
])
18774  18775   
                        )
18775  18776   
                    ),
18776  18777   
                )
18777  18778   
    }
18778  18779   
    pub(super) fn malformed_content_type_without_body(
18779  18780   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18780  18781   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18781         -
                    ::http::Method::POST,
       18782  +
                    ::http_1x::Method::POST,
18782  18783   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18783  18784   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18784  18785   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18785  18786   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedContentTypeWithoutBody")),
18786  18787   
]),
18787  18788   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18788  18789   
])
18789  18790   
                        )
18790  18791   
                    ),
18791  18792   
                )
18792  18793   
    }
18793  18794   
    pub(super) fn malformed_content_type_without_body_empty_input(
18794  18795   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18795  18796   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18796         -
                    ::http::Method::POST,
       18797  +
                    ::http_1x::Method::POST,
18797  18798   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18798  18799   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18799  18800   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18800  18801   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedContentTypeWithoutBodyEmptyInput")),
18801  18802   
]),
18802  18803   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18803  18804   
])
18804  18805   
                        )
18805  18806   
                    ),
18806  18807   
                )
18807  18808   
    }
18808  18809   
    pub(super) fn malformed_content_type_with_payload(
18809  18810   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18810  18811   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18811         -
                    ::http::Method::POST,
       18812  +
                    ::http_1x::Method::POST,
18812  18813   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18813  18814   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18814  18815   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18815  18816   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedContentTypeWithPayload")),
18816  18817   
]),
18817  18818   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18818  18819   
])
18819  18820   
                        )
18820  18821   
                    ),
18821  18822   
                )
18822  18823   
    }
18823  18824   
    pub(super) fn malformed_double() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18824  18825   
    {
18825  18826   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18826         -
                    ::http::Method::POST,
       18827  +
                    ::http_1x::Method::POST,
18827  18828   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18828  18829   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18829  18830   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18830  18831   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedDouble")),
18831  18832   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18832  18833   
]),
18833  18834   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18834  18835   
])
18835  18836   
                        )
18836  18837   
                    ),
18837  18838   
                )
18838  18839   
    }
18839  18840   
    pub(super) fn malformed_float() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18840  18841   
    {
18841  18842   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18842         -
                    ::http::Method::POST,
       18843  +
                    ::http_1x::Method::POST,
18843  18844   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18844  18845   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18845  18846   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18846  18847   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedFloat")),
18847  18848   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18848  18849   
]),
18849  18850   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18850  18851   
])
18851  18852   
                        )
18852  18853   
                    ),
18853  18854   
                )
18854  18855   
    }
18855  18856   
    pub(super) fn malformed_integer() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18856  18857   
    {
18857  18858   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18858         -
                    ::http::Method::POST,
       18859  +
                    ::http_1x::Method::POST,
18859  18860   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18860  18861   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18861  18862   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18862  18863   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedInteger")),
18863  18864   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18864  18865   
]),
18865  18866   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18866  18867   
])
18867  18868   
                        )
18868  18869   
                    ),
18869  18870   
                )
18870  18871   
    }
18871  18872   
    pub(super) fn malformed_list() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18872  18873   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18873         -
                    ::http::Method::POST,
       18874  +
                    ::http_1x::Method::POST,
18874  18875   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18875  18876   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18876  18877   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18877  18878   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedList")),
18878  18879   
]),
18879  18880   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18880  18881   
])
18881  18882   
                        )
18882  18883   
                    ),
18883  18884   
                )
18884  18885   
    }
18885  18886   
    pub(super) fn malformed_long() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18886  18887   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18887         -
                    ::http::Method::POST,
       18888  +
                    ::http_1x::Method::POST,
18888  18889   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18889  18890   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18890  18891   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18891  18892   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedLong")),
18892  18893   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18893  18894   
]),
18894  18895   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18895  18896   
])
18896  18897   
                        )
18897  18898   
                    ),
18898  18899   
                )
18899  18900   
    }
18900  18901   
    pub(super) fn malformed_map() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18901  18902   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18902         -
                    ::http::Method::POST,
       18903  +
                    ::http_1x::Method::POST,
18903  18904   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18904  18905   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18905  18906   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18906  18907   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedMap")),
18907  18908   
]),
18908  18909   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18909  18910   
])
18910  18911   
                        )
18911  18912   
                    ),
18912  18913   
                )
18913  18914   
    }
18914  18915   
    pub(super) fn malformed_request_body(
18915  18916   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18916  18917   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18917         -
                    ::http::Method::POST,
       18918  +
                    ::http_1x::Method::POST,
18918  18919   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18919  18920   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18920  18921   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18921  18922   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedRequestBody")),
18922  18923   
]),
18923  18924   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18924  18925   
])
18925  18926   
                        )
18926  18927   
                    ),
18927  18928   
                )
18928  18929   
    }
18929  18930   
    pub(super) fn malformed_short() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18930  18931   
    {
18931  18932   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18932         -
                    ::http::Method::POST,
       18933  +
                    ::http_1x::Method::POST,
18933  18934   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18934  18935   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18935  18936   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18936  18937   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedShort")),
18937  18938   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
18938  18939   
]),
18939  18940   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18940  18941   
])
18941  18942   
                        )
18942  18943   
                    ),
18943  18944   
                )
18944  18945   
    }
18945  18946   
    pub(super) fn malformed_string() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
18946  18947   
    {
18947  18948   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18948         -
                    ::http::Method::POST,
       18949  +
                    ::http_1x::Method::POST,
18949  18950   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18950  18951   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18951  18952   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18952  18953   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedString")),
18953  18954   
]),
18954  18955   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18955  18956   
])
18956  18957   
                        )
18957  18958   
                    ),
18958  18959   
                )
18959  18960   
    }
18960  18961   
    pub(super) fn malformed_timestamp_body_date_time(
18961  18962   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18962  18963   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18963         -
                    ::http::Method::POST,
       18964  +
                    ::http_1x::Method::POST,
18964  18965   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18965  18966   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18966  18967   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18967  18968   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampBodyDateTime")),
18968  18969   
]),
18969  18970   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18970  18971   
])
18971  18972   
                        )
18972  18973   
                    ),
18973  18974   
                )
18974  18975   
    }
18975  18976   
    pub(super) fn malformed_timestamp_body_default(
18976  18977   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18977  18978   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18978         -
                    ::http::Method::POST,
       18979  +
                    ::http_1x::Method::POST,
18979  18980   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18980  18981   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18981  18982   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18982  18983   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampBodyDefault")),
18983  18984   
]),
18984  18985   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
18985  18986   
])
18986  18987   
                        )
18987  18988   
                    ),
18988  18989   
                )
18989  18990   
    }
18990  18991   
    pub(super) fn malformed_timestamp_body_http_date(
18991  18992   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
18992  18993   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
18993         -
                    ::http::Method::POST,
       18994  +
                    ::http_1x::Method::POST,
18994  18995   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
18995  18996   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
18996  18997   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
18997  18998   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampBodyHttpDate")),
18998  18999   
]),
18999  19000   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19000  19001   
])
19001  19002   
                        )
19002  19003   
                    ),
19003  19004   
                )
19004  19005   
    }
19005  19006   
    pub(super) fn malformed_timestamp_header_date_time(
19006  19007   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19007  19008   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19008         -
                    ::http::Method::POST,
       19009  +
                    ::http_1x::Method::POST,
19009  19010   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19010  19011   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19011  19012   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19012  19013   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampHeaderDateTime")),
19013  19014   
]),
19014  19015   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19015  19016   
])
19016  19017   
                        )
19017  19018   
                    ),
19018  19019   
                )
19019  19020   
    }
19020  19021   
    pub(super) fn malformed_timestamp_header_default(
19021  19022   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19022  19023   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19023         -
                    ::http::Method::POST,
       19024  +
                    ::http_1x::Method::POST,
19024  19025   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19025  19026   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19026  19027   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19027  19028   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampHeaderDefault")),
19028  19029   
]),
19029  19030   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19030  19031   
])
19031  19032   
                        )
19032  19033   
                    ),
19033  19034   
                )
19034  19035   
    }
19035  19036   
    pub(super) fn malformed_timestamp_header_epoch(
19036  19037   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19037  19038   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19038         -
                    ::http::Method::POST,
       19039  +
                    ::http_1x::Method::POST,
19039  19040   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19040  19041   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19041  19042   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19042  19043   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampHeaderEpoch")),
19043  19044   
]),
19044  19045   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19045  19046   
])
19046  19047   
                        )
19047  19048   
                    ),
19048  19049   
                )
19049  19050   
    }
19050  19051   
    pub(super) fn malformed_timestamp_path_default(
19051  19052   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19052  19053   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19053         -
                    ::http::Method::POST,
       19054  +
                    ::http_1x::Method::POST,
19054  19055   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19055  19056   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19056  19057   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19057  19058   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampPathDefault")),
19058  19059   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
19059  19060   
]),
19060  19061   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19061  19062   
])
19062  19063   
                        )
19063  19064   
                    ),
19064  19065   
                )
19065  19066   
    }
19066  19067   
    pub(super) fn malformed_timestamp_path_epoch(
19067  19068   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19068  19069   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19069         -
                    ::http::Method::POST,
       19070  +
                    ::http_1x::Method::POST,
19070  19071   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19071  19072   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19072  19073   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19073  19074   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampPathEpoch")),
19074  19075   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
19075  19076   
]),
19076  19077   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19077  19078   
])
19078  19079   
                        )
19079  19080   
                    ),
19080  19081   
                )
19081  19082   
    }
19082  19083   
    pub(super) fn malformed_timestamp_path_http_date(
19083  19084   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19084  19085   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19085         -
                    ::http::Method::POST,
       19086  +
                    ::http_1x::Method::POST,
19086  19087   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19087  19088   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19088  19089   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19089  19090   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampPathHttpDate")),
19090  19091   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Label,
19091  19092   
]),
19092  19093   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19093  19094   
])
19094  19095   
                        )
19095  19096   
                    ),
19096  19097   
                )
19097  19098   
    }
19098  19099   
    pub(super) fn malformed_timestamp_query_default(
19099  19100   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19100  19101   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19101         -
                    ::http::Method::POST,
       19102  +
                    ::http_1x::Method::POST,
19102  19103   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19103  19104   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19104  19105   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19105  19106   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampQueryDefault")),
19106  19107   
]),
19107  19108   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19108  19109   
])
19109  19110   
                        )
19110  19111   
                    ),
19111  19112   
                )
19112  19113   
    }
19113  19114   
    pub(super) fn malformed_timestamp_query_epoch(
19114  19115   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19115  19116   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19116         -
                    ::http::Method::POST,
       19117  +
                    ::http_1x::Method::POST,
19117  19118   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19118  19119   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19119  19120   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19120  19121   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampQueryEpoch")),
19121  19122   
]),
19122  19123   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19123  19124   
])
19124  19125   
                        )
19125  19126   
                    ),
19126  19127   
                )
19127  19128   
    }
19128  19129   
    pub(super) fn malformed_timestamp_query_http_date(
19129  19130   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19130  19131   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19131         -
                    ::http::Method::POST,
       19132  +
                    ::http_1x::Method::POST,
19132  19133   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19133  19134   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19134  19135   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19135  19136   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedTimestampQueryHttpDate")),
19136  19137   
]),
19137  19138   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19138  19139   
])
19139  19140   
                        )
19140  19141   
                    ),
19141  19142   
                )
19142  19143   
    }
19143  19144   
    pub(super) fn malformed_union() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19144  19145   
    {
19145  19146   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19146         -
                    ::http::Method::POST,
       19147  +
                    ::http_1x::Method::POST,
19147  19148   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19148  19149   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19149  19150   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19150  19151   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MalformedUnion")),
19151  19152   
]),
19152  19153   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19153  19154   
])
19154  19155   
                        )
19155  19156   
                    ),
19156  19157   
                )
19157  19158   
    }
19158  19159   
    pub(super) fn media_type_header() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19159  19160   
    {
19160  19161   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19161         -
                    ::http::Method::GET,
       19162  +
                    ::http_1x::Method::GET,
19162  19163   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19163  19164   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19164  19165   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19165  19166   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("MediaTypeHeader")),
19166  19167   
]),
19167  19168   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19168  19169   
])
19169  19170   
                        )
19170  19171   
                    ),
19171  19172   
                )
19172  19173   
    }
19173  19174   
    pub(super) fn no_input_and_no_output(
19174  19175   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19175  19176   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19176         -
                    ::http::Method::POST,
       19177  +
                    ::http_1x::Method::POST,
19177  19178   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19178  19179   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19179  19180   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19180  19181   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("NoInputAndNoOutput")),
19181  19182   
]),
19182  19183   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19183  19184   
])
19184  19185   
                        )
19185  19186   
                    ),
19186  19187   
                )
19187  19188   
    }
19188  19189   
    pub(super) fn no_input_and_output(
19189  19190   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19190  19191   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19191         -
                    ::http::Method::POST,
       19192  +
                    ::http_1x::Method::POST,
19192  19193   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19193  19194   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19194  19195   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19195  19196   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("NoInputAndOutputOutput")),
19196  19197   
]),
19197  19198   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19198  19199   
])
19199  19200   
                        )
19200  19201   
                    ),
19201  19202   
                )
19202  19203   
    }
19203  19204   
    pub(super) fn null_and_empty_headers_client(
19204  19205   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19205  19206   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19206         -
                    ::http::Method::GET,
       19207  +
                    ::http_1x::Method::GET,
19207  19208   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19208  19209   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19209  19210   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19210  19211   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("NullAndEmptyHeadersClient")),
19211  19212   
]),
19212  19213   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19213  19214   
])
19214  19215   
                        )
19215  19216   
                    ),
19216  19217   
                )
19217  19218   
    }
19218  19219   
    pub(super) fn null_and_empty_headers_server(
19219  19220   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19220  19221   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19221         -
                    ::http::Method::GET,
       19222  +
                    ::http_1x::Method::GET,
19222  19223   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19223  19224   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19224  19225   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19225  19226   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("NullAndEmptyHeadersServer")),
19226  19227   
]),
19227  19228   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19228  19229   
])
19229  19230   
                        )
19230  19231   
                    ),
19231  19232   
                )
19232  19233   
    }
19233  19234   
    pub(super) fn omits_null_serializes_empty_string(
19234  19235   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19235  19236   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19236         -
                    ::http::Method::GET,
       19237  +
                    ::http_1x::Method::GET,
19237  19238   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19238  19239   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19239  19240   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19240  19241   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("OmitsNullSerializesEmptyString")),
19241  19242   
]),
19242  19243   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19243  19244   
])
19244  19245   
                        )
19245  19246   
                    ),
19246  19247   
                )
19247  19248   
    }
19248  19249   
    pub(super) fn omits_serializing_empty_lists(
19249  19250   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19250  19251   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19251         -
                    ::http::Method::POST,
       19252  +
                    ::http_1x::Method::POST,
19252  19253   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19253  19254   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19254  19255   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19255  19256   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("OmitsSerializingEmptyLists")),
19256  19257   
]),
19257  19258   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19258  19259   
])
19259  19260   
                        )
19260  19261   
                    ),
19261  19262   
                )
19262  19263   
    }
19263  19264   
    pub(super) fn operation_with_defaults(
19264  19265   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19265  19266   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19266         -
                    ::http::Method::POST,
       19267  +
                    ::http_1x::Method::POST,
19267  19268   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19268  19269   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19269  19270   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19270  19271   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("OperationWithDefaults")),
19271  19272   
]),
19272  19273   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19273  19274   
])
19274  19275   
                        )
19275  19276   
                    ),
19276  19277   
                )
19277  19278   
    }
19278  19279   
    pub(super) fn operation_with_nested_structure(
19279  19280   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19280  19281   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19281         -
                    ::http::Method::POST,
       19282  +
                    ::http_1x::Method::POST,
19282  19283   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19283  19284   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19284  19285   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19285  19286   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("OperationWithNestedStructure")),
19286  19287   
]),
19287  19288   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19288  19289   
])
19289  19290   
                        )
19290  19291   
                    ),
19291  19292   
                )
19292  19293   
    }
19293  19294   
    pub(super) fn post_player_action(
19294  19295   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19295  19296   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19296         -
                    ::http::Method::POST,
       19297  +
                    ::http_1x::Method::POST,
19297  19298   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19298  19299   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19299  19300   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19300  19301   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("PostPlayerAction")),
19301  19302   
]),
19302  19303   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19303  19304   
])
19304  19305   
                        )
19305  19306   
                    ),
19306  19307   
                )
19307  19308   
    }
19308  19309   
    pub(super) fn post_union_with_json_name(
19309  19310   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19310  19311   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19311         -
                    ::http::Method::POST,
       19312  +
                    ::http_1x::Method::POST,
19312  19313   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19313  19314   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19314  19315   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19315  19316   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("PostUnionWithJsonName")),
19316  19317   
]),
19317  19318   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19318  19319   
])
19319  19320   
                        )
19320  19321   
                    ),
19321  19322   
                )
19322  19323   
    }
19323  19324   
    pub(super) fn put_with_content_encoding(
19324  19325   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19325  19326   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19326         -
                    ::http::Method::POST,
       19327  +
                    ::http_1x::Method::POST,
19327  19328   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19328  19329   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19329  19330   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19330  19331   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("requestcompression")),
19331  19332   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("putcontentwithencoding")),
19332  19333   
]),
19333  19334   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19334  19335   
])
19335  19336   
                        )
19336  19337   
                    ),
19337  19338   
                )
19338  19339   
    }
19339  19340   
    pub(super) fn query_idempotency_token_auto_fill(
19340  19341   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19341  19342   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19342         -
                    ::http::Method::POST,
       19343  +
                    ::http_1x::Method::POST,
19343  19344   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19344  19345   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19345  19346   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19346  19347   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("QueryIdempotencyTokenAutoFill")),
19347  19348   
]),
19348  19349   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19349  19350   
])
19350  19351   
                        )
19351  19352   
                    ),
19352  19353   
                )
19353  19354   
    }
19354  19355   
    pub(super) fn query_params_as_string_list_map(
19355  19356   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19356  19357   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19357         -
                    ::http::Method::POST,
       19358  +
                    ::http_1x::Method::POST,
19358  19359   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19359  19360   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19360  19361   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19361  19362   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("StringListMap")),
19362  19363   
]),
19363  19364   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19364  19365   
])
19365  19366   
                        )
19366  19367   
                    ),
19367  19368   
                )
19368  19369   
    }
19369  19370   
    pub(super) fn query_precedence() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19370  19371   
    {
19371  19372   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19372         -
                    ::http::Method::POST,
       19373  +
                    ::http_1x::Method::POST,
19373  19374   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19374  19375   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19375  19376   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19376  19377   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("Precedence")),
19377  19378   
]),
19378  19379   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19379  19380   
])
19380  19381   
                        )
19381  19382   
                    ),
19382  19383   
                )
19383  19384   
    }
19384  19385   
    pub(super) fn recursive_shapes() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19385  19386   
    {
19386  19387   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19387         -
                    ::http::Method::PUT,
       19388  +
                    ::http_1x::Method::PUT,
19388  19389   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19389  19390   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19390  19391   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19391  19392   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("RecursiveShapes")),
19392  19393   
]),
19393  19394   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19394  19395   
])
19395  19396   
                        )
19396  19397   
                    ),
19397  19398   
                )
19398  19399   
    }
19399  19400   
    pub(super) fn response_code_http_fallback(
19400  19401   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19401  19402   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19402         -
                    ::http::Method::GET,
       19403  +
                    ::http_1x::Method::GET,
19403  19404   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19404  19405   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19405  19406   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19406  19407   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("responseCodeHttpFallback")),
19407  19408   
]),
19408  19409   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19409  19410   
])
19410  19411   
                        )
19411  19412   
                    ),
19412  19413   
                )
19413  19414   
    }
19414  19415   
    pub(super) fn response_code_required(
19415  19416   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19416  19417   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19417         -
                    ::http::Method::GET,
       19418  +
                    ::http_1x::Method::GET,
19418  19419   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19419  19420   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19420  19421   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19421  19422   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("responseCodeRequired")),
19422  19423   
]),
19423  19424   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19424  19425   
])
19425  19426   
                        )
19426  19427   
                    ),
19427  19428   
                )
19428  19429   
    }
19429  19430   
    pub(super) fn simple_scalar_properties(
19430  19431   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19431  19432   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19432         -
                    ::http::Method::PUT,
       19433  +
                    ::http_1x::Method::PUT,
19433  19434   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19434  19435   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19435  19436   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19436  19437   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("SimpleScalarProperties")),
19437  19438   
]),
19438  19439   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19439  19440   
])
19440  19441   
                        )
19441  19442   
                    ),
19442  19443   
                )
19443  19444   
    }
19444  19445   
    pub(super) fn sparse_json_lists() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19445  19446   
    {
19446  19447   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19447         -
                    ::http::Method::PUT,
       19448  +
                    ::http_1x::Method::PUT,
19448  19449   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19449  19450   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19450  19451   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19451  19452   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("SparseJsonLists")),
19452  19453   
]),
19453  19454   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19454  19455   
])
19455  19456   
                        )
19456  19457   
                    ),
19457  19458   
                )
19458  19459   
    }
19459  19460   
    pub(super) fn sparse_json_maps() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19460  19461   
    {
19461  19462   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19462         -
                    ::http::Method::POST,
       19463  +
                    ::http_1x::Method::POST,
19463  19464   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19464  19465   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19465  19466   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19466  19467   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("SparseJsonMaps")),
19467  19468   
]),
19468  19469   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19469  19470   
])
19470  19471   
                        )
19471  19472   
                    ),
19472  19473   
                )
19473  19474   
    }
19474  19475   
    pub(super) fn streaming_traits() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19475  19476   
    {
19476  19477   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19477         -
                    ::http::Method::POST,
       19478  +
                    ::http_1x::Method::POST,
19478  19479   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19479  19480   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19480  19481   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19481  19482   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("StreamingTraits")),
19482  19483   
]),
19483  19484   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19484  19485   
])
19485  19486   
                        )
19486  19487   
                    ),
19487  19488   
                )
19488  19489   
    }
19489  19490   
    pub(super) fn streaming_traits_require_length(
19490  19491   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19491  19492   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19492         -
                    ::http::Method::POST,
       19493  +
                    ::http_1x::Method::POST,
19493  19494   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19494  19495   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19495  19496   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19496  19497   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("StreamingTraitsRequireLength")),
19497  19498   
]),
19498  19499   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19499  19500   
])
19500  19501   
                        )
19501  19502   
                    ),
19502  19503   
                )
19503  19504   
    }
19504  19505   
    pub(super) fn streaming_traits_with_media_type(
19505  19506   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19506  19507   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19507         -
                    ::http::Method::POST,
       19508  +
                    ::http_1x::Method::POST,
19508  19509   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19509  19510   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19510  19511   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19511  19512   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("StreamingTraitsWithMediaType")),
19512  19513   
]),
19513  19514   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19514  19515   
])
19515  19516   
                        )
19516  19517   
                    ),
19517  19518   
                )
19518  19519   
    }
19519  19520   
    pub(super) fn test_body_structure(
19520  19521   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19521  19522   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19522         -
                    ::http::Method::POST,
       19523  +
                    ::http_1x::Method::POST,
19523  19524   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19524  19525   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19525  19526   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19526  19527   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("body")),
19527  19528   
]),
19528  19529   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19529  19530   
])
19530  19531   
                        )
19531  19532   
                    ),
19532  19533   
                )
19533  19534   
    }
19534  19535   
    pub(super) fn test_get_no_input_no_payload(
19535  19536   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19536  19537   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19537         -
                    ::http::Method::GET,
       19538  +
                    ::http_1x::Method::GET,
19538  19539   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19539  19540   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19540  19541   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19541  19542   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("no_input_no_payload")),
19542  19543   
]),
19543  19544   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19544  19545   
])
19545  19546   
                        )
19546  19547   
                    ),
19547  19548   
                )
19548  19549   
    }
19549  19550   
    pub(super) fn test_get_no_payload(
19550  19551   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19551  19552   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19552         -
                    ::http::Method::GET,
       19553  +
                    ::http_1x::Method::GET,
19553  19554   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19554  19555   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19555  19556   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19556  19557   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("no_payload")),
19557  19558   
]),
19558  19559   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19559  19560   
])
19560  19561   
                        )
19561  19562   
                    ),
19562  19563   
                )
19563  19564   
    }
19564  19565   
    pub(super) fn test_payload_blob() -> ::aws_smithy_http_server::routing::request_spec::RequestSpec
19565  19566   
    {
19566  19567   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19567         -
                    ::http::Method::POST,
       19568  +
                    ::http_1x::Method::POST,
19568  19569   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19569  19570   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19570  19571   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19571  19572   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("blob_payload")),
19572  19573   
]),
19573  19574   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19574  19575   
])
19575  19576   
                        )
19576  19577   
                    ),
19577  19578   
                )
19578  19579   
    }
19579  19580   
    pub(super) fn test_payload_structure(
19580  19581   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19581  19582   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19582         -
                    ::http::Method::POST,
       19583  +
                    ::http_1x::Method::POST,
19583  19584   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19584  19585   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19585  19586   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19586  19587   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("payload")),
19587  19588   
]),
19588  19589   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19589  19590   
])
19590  19591   
                        )
19591  19592   
                    ),
19592  19593   
                )
19593  19594   
    }
19594  19595   
    pub(super) fn test_post_no_input_no_payload(
19595  19596   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19596  19597   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19597         -
                    ::http::Method::POST,
       19598  +
                    ::http_1x::Method::POST,
19598  19599   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19599  19600   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19600  19601   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19601  19602   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("no_input_no_payload")),
19602  19603   
]),
19603  19604   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19604  19605   
])
19605  19606   
                        )
19606  19607   
                    ),
19607  19608   
                )
19608  19609   
    }
19609  19610   
    pub(super) fn test_post_no_payload(
19610  19611   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19611  19612   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19612         -
                    ::http::Method::POST,
       19613  +
                    ::http_1x::Method::POST,
19613  19614   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19614  19615   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19615  19616   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19616  19617   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("no_payload")),
19617  19618   
]),
19618  19619   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19619  19620   
])
19620  19621   
                        )
19621  19622   
                    ),
19622  19623   
                )
19623  19624   
    }
19624  19625   
    pub(super) fn timestamp_format_headers(
19625  19626   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19626  19627   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19627         -
                    ::http::Method::POST,
       19628  +
                    ::http_1x::Method::POST,
19628  19629   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19629  19630   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19630  19631   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19631  19632   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("TimestampFormatHeaders")),
19632  19633   
]),
19633  19634   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19634  19635   
])
19635  19636   
                        )
19636  19637   
                    ),
19637  19638   
                )
19638  19639   
    }
19639  19640   
    pub(super) fn unit_input_and_output(
19640  19641   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
19641  19642   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
19642         -
                    ::http::Method::POST,
       19643  +
                    ::http_1x::Method::POST,
19643  19644   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
19644  19645   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
19645  19646   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
19646  19647   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("UnitInputAndOutput")),
19647  19648   
]),
19648  19649   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
19649  19650   
])
19650  19651   
                        )
19651  19652   
                    ),
19652  19653   
                )
@@ -19977,19978 +20038,20039 @@
19997  19998   
    ) -> RestJson<
19998  19999   
        ::aws_smithy_http_server::routing::RoutingService<
19999  20000   
            ::aws_smithy_http_server::protocol::rest::router::RestRouter<
20000  20001   
                ::aws_smithy_http_server::routing::Route<B>,
20001  20002   
            >,
20002  20003   
            ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
20003  20004   
        >,
20004  20005   
    >
20005  20006   
    where
20006  20007   
        S: ::tower::Service<
20007         -
            ::http::Request<B>,
20008         -
            Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
       20008  +
            ::http_1x::Request<B>,
       20009  +
            Response = ::http_1x::Response<::aws_smithy_http_server::body::BoxBody>,
20009  20010   
            Error = std::convert::Infallible,
20010  20011   
        >,
20011  20012   
        S: Clone + Send + 'static,
20012  20013   
        S::Future: Send + 'static,
20013  20014   
    {
20014  20015   
        self.layer(&::tower::layer::layer_fn(
20015  20016   
            ::aws_smithy_http_server::routing::Route::new,
20016  20017   
        ))
20017  20018   
    }
20018  20019   
}
@@ -21427,21428 +21486,21488 @@
21447  21448   
            "aws.protocoltests.restjson",
21448  21449   
            "RestJson",
21449  21450   
        );
21450  21451   
21451  21452   
    const VERSION: Option<&'static str> = Some("2019-12-16");
21452  21453   
21453  21454   
    type Protocol = ::aws_smithy_http_server::protocol::rest_json_1::RestJson1;
21454  21455   
21455  21456   
    type Operations = Operation;
21456  21457   
}
       21458  +
/* ServiceConfigGenerator.kt:178 */
21457  21459   
/// Configuration for the [`RestJson`]. This is the central place where to register and
21458  21460   
/// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
21459  21461   
///
21460  21462   
/// ```rust,no_run
21461  21463   
/// # use rest_json::RestJsonConfig;
21462  21464   
/// # use ::aws_smithy_http_server::plugin::IdentityPlugin;
21463  21465   
/// # use ::tower::layer::util::Identity;
21464  21466   
/// # let authentication_plugin = IdentityPlugin;
21465  21467   
/// # let authorization_plugin = IdentityPlugin;
21466  21468   
/// # let server_request_id_provider_layer = Identity::new();
@@ -21542,21544 +21601,21604 @@
21562  21564   
21563  21565   
    /// Build the configuration.
21564  21566   
    pub fn build(self) -> super::RestJsonConfig<L, H, M> {
21565  21567   
        super::RestJsonConfig {
21566  21568   
            layers: self.layers,
21567  21569   
            http_plugins: self.http_plugins,
21568  21570   
            model_plugins: self.model_plugins,
21569  21571   
        }
21570  21572   
    }
21571  21573   
}
       21574  +
/* ScopeMacroGenerator.kt:81 */
21572  21575   
/// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
21573  21576   
///
21574  21577   
/// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
21575  21578   
/// of the service and any operations _not_ specified will be placed in the opposing group.
21576  21579   
///
21577  21580   
/// # Example
21578  21581   
///
21579  21582   
/// ```rust
21580  21583   
/// scope! {
21581  21584   
///     /// Includes [`AllQueryStringTypes`], excluding all other operations.