Server Test

Server Test

rev. dfb5149b65b7bcc09edd15b8e071ad43b5ac5943 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_con_b.rs

@@ -1,1 +111,158 @@
    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_con_b<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::model::con_b::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:516 */
   19     23   
            #[allow(unused_mut)]
          24  +
            /* JsonParserGenerator.kt:526 */
   20     25   
            let mut builder = crate::model::con_b::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     32   
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
          33  +
                        /* JsonParserGenerator.kt:260 */
   25     34   
                        match key.to_unescaped()?.as_ref() {
          35  +
                            /* JsonParserGenerator.kt:262 */
   26     36   
                            "nice" => {
          37  +
                                /* JsonParserGenerator.kt:276 */
   27     38   
                                if let Some(v) =
   28         -
                                    ::aws_smithy_json::deserialize::token::expect_string_or_null(
   29         -
                                        tokens.next(),
   30         -
                                    )?
   31         -
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   32         -
                                    .transpose()?
   33         -
                                {
          39  +
                                /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          40  +
                                    /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          41  +
                                        /* JsonParserGenerator.kt:348 */u.into_owned()
          42  +
                                    /* JsonParserGenerator.kt:339 */)
          43  +
                                /* JsonParserGenerator.kt:354 */).transpose()?
          44  +
                                /* JsonParserGenerator.kt:278 */{
   34     45   
                                                                            builder = builder.set_nice(v);
   35     46   
                                                                        }
          47  +
                                /* JsonParserGenerator.kt:262 */
   36     48   
                            }
          49  +
                            /* JsonParserGenerator.kt:262 */
   37     50   
                            "int" => {
          51  +
                                /* JsonParserGenerator.kt:276 */
   38     52   
                                if let Some(v) =
   39         -
                                    ::aws_smithy_json::deserialize::token::expect_number_or_null(
   40         -
                                        tokens.next(),
   41         -
                                    )?
          53  +
                                /* JsonParserGenerator.kt:365 */::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
   42     54   
                                                    .map(i32::try_from)
   43     55   
                                                    .transpose()?
   44         -
                                {
          56  +
                                /* JsonParserGenerator.kt:278 */{
   45     57   
                                                                            builder = builder.set_int(v);
   46     58   
                                                                        }
          59  +
                                /* JsonParserGenerator.kt:262 */
   47     60   
                            }
          61  +
                            /* JsonParserGenerator.kt:262 */
   48     62   
                            "optNice" => {
          63  +
                                /* JsonParserGenerator.kt:272 */
   49     64   
                                builder = builder.set_opt_nice(
   50         -
                                    ::aws_smithy_json::deserialize::token::expect_string_or_null(
   51         -
                                        tokens.next(),
   52         -
                                    )?
   53         -
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   54         -
                                    .transpose()?,
   55         -
                                );
   56         -
                            }
          65  +
                                    /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          66  +
                                        /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          67  +
                                            /* JsonParserGenerator.kt:348 */u.into_owned()
          68  +
                                        /* JsonParserGenerator.kt:339 */)
          69  +
                                    /* JsonParserGenerator.kt:354 */).transpose()?
          70  +
                                /* JsonParserGenerator.kt:272 */);
          71  +
                                /* JsonParserGenerator.kt:262 */
          72  +
                            }
          73  +
                            /* JsonParserGenerator.kt:262 */
   57     74   
                            "optInt" => {
          75  +
                                /* JsonParserGenerator.kt:272 */
   58     76   
                                builder = builder.set_opt_int(
          77  +
                                    /* JsonParserGenerator.kt:365 */
   59     78   
                                    ::aws_smithy_json::deserialize::token::expect_number_or_null(
   60     79   
                                        tokens.next(),
   61     80   
                                    )?
   62     81   
                                    .map(i32::try_from)
   63         -
                                    .transpose()?,
          82  +
                                    .transpose()?, /* JsonParserGenerator.kt:272 */
   64     83   
                                );
          84  +
                                /* JsonParserGenerator.kt:262 */
   65     85   
                            }
   66         -
                            _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
          86  +
                            /* JsonParserGenerator.kt:290 */
          87  +
                            _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:260 */
   67     88   
                        }
          89  +
                        /* JsonParserGenerator.kt:686 */
   68     90   
                    }
          91  +
                    /* JsonParserGenerator.kt:695 */
   69     92   
                    other => {
   70     93   
                        return Err(
   71     94   
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   72     95   
                                format!("expected object key or end object, found: {:?}", other),
   73     96   
                            ),
   74     97   
                        )
          98  +
                    } /* JsonParserGenerator.kt:685 */
   75     99   
                }
         100  +
                /* JsonParserGenerator.kt:684 */
   76    101   
            }
   77         -
            }
         102  +
            /* JsonParserGenerator.kt:540 */
   78    103   
            Ok(Some(builder))
         104  +
            /* JsonParserGenerator.kt:713 */
   79    105   
        }
   80         -
        _ => Err(
         106  +
        /* JsonParserGenerator.kt:722 */
         107  +
        _ => {
         108  +
            /* JsonParserGenerator.kt:723 */
         109  +
            Err(
   81    110   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   82    111   
                    "expected start object or null",
   83    112   
                ),
   84         -
        ),
         113  +
            )
         114  +
            /* JsonParserGenerator.kt:722 */
         115  +
        } /* JsonParserGenerator.kt:712 */
   85    116   
    }
         117  +
    /* JsonParserGenerator.kt:516 */
   86    118   
}
   87    119   
         120  +
/* JsonSerializerGenerator.kt:358 */
   88    121   
pub fn ser_con_b(
   89    122   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
   90    123   
    input: &crate::model::ConB,
   91    124   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
         125  +
    /* SerializerUtil.kt:42 */
   92    126   
    {
         127  +
        /* JsonSerializerGenerator.kt:423 */
   93    128   
        object.key("nice").string(input.nice.as_str());
         129  +
        /* SerializerUtil.kt:42 */
   94    130   
    }
         131  +
    /* SerializerUtil.kt:42 */
   95    132   
    {
         133  +
        /* JsonSerializerGenerator.kt:432 */
   96    134   
        object.key("int").number(
   97    135   
            #[allow(clippy::useless_conversion)]
   98    136   
            ::aws_smithy_types::Number::NegInt((input.int).into()),
   99    137   
        );
         138  +
        /* SerializerUtil.kt:42 */
  100    139   
    }
         140  +
    /* JsonSerializerGenerator.kt:382 */
  101    141   
    if let Some(var_1) = &input.opt_nice {
         142  +
        /* JsonSerializerGenerator.kt:423 */
  102    143   
        object.key("optNice").string(var_1.as_str());
         144  +
        /* JsonSerializerGenerator.kt:382 */
  103    145   
    }
         146  +
    /* JsonSerializerGenerator.kt:382 */
  104    147   
    if let Some(var_2) = &input.opt_int {
         148  +
        /* JsonSerializerGenerator.kt:432 */
  105    149   
        object.key("optInt").number(
  106    150   
            #[allow(clippy::useless_conversion)]
  107    151   
            ::aws_smithy_types::Number::NegInt((*var_2).into()),
  108    152   
        );
         153  +
        /* JsonSerializerGenerator.kt:382 */
  109    154   
    }
         155  +
    /* JsonSerializerGenerator.kt:372 */
  110    156   
    Ok(())
         157  +
    /* JsonSerializerGenerator.kt:358 */
  111    158   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_con_b_list.rs

@@ -1,1 +53,76 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:398 */
    2      3   
pub(crate) fn de_con_b_list<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained>,
    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::StartArray { .. }) => {
          22  +
            /* JsonParserGenerator.kt:407 */
   19     23   
            let mut items = Vec::new();
          24  +
            /* JsonParserGenerator.kt:408 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:409 */
   21     27   
                match tokens.peek() {
          28  +
                    /* JsonParserGenerator.kt:410 */
   22     29   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          30  +
                        /* JsonParserGenerator.kt:411 */
   23     31   
                        tokens.next().transpose().unwrap();
   24     32   
                        break;
          33  +
                        /* JsonParserGenerator.kt:410 */
   25     34   
                    }
          35  +
                    /* JsonParserGenerator.kt:413 */
   26     36   
                    _ => {
          37  +
                        /* JsonParserGenerator.kt:419 */
   27     38   
                        let value =
   28         -
                            crate::protocol_serde::shape_con_b_list_inner::de_con_b_list_inner(
   29         -
                                tokens,
   30         -
                            )?;
          39  +
                            /* JsonParserGenerator.kt:451 */crate::protocol_serde::shape_con_b_list_inner::de_con_b_list_inner(tokens)?
          40  +
                        /* JsonParserGenerator.kt:419 */;
          41  +
                        /* JsonParserGenerator.kt:422 */
   31     42   
                        if let Some(value) = value {
   32     43   
                            items.push(value);
   33         -
                        } else {
          44  +
                        }
          45  +
                        /* JsonParserGenerator.kt:430 */
          46  +
                        else {
   34     47   
                            return Err(
   35     48   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   36     49   
                                    "dense list cannot contain null values",
   37     50   
                                ),
   38     51   
                            );
   39     52   
                        }
          53  +
                        /* JsonParserGenerator.kt:413 */
          54  +
                    } /* JsonParserGenerator.kt:409 */
   40     55   
                }
          56  +
                /* JsonParserGenerator.kt:408 */
   41     57   
            }
   42         -
            }
          58  +
            /* JsonParserGenerator.kt:444 */
   43     59   
            Ok(Some(
   44     60   
                crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained(items),
   45     61   
            ))
          62  +
            /* JsonParserGenerator.kt:713 */
   46     63   
        }
   47         -
        _ => Err(
          64  +
        /* JsonParserGenerator.kt:722 */
          65  +
        _ => {
          66  +
            /* JsonParserGenerator.kt:723 */
          67  +
            Err(
   48     68   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   49     69   
                    "expected start array or null",
   50     70   
                ),
   51         -
        ),
          71  +
            )
          72  +
            /* JsonParserGenerator.kt:722 */
          73  +
        } /* JsonParserGenerator.kt:712 */
   52     74   
    }
          75  +
    /* JsonParserGenerator.kt:398 */
   53     76   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_con_b_list_inner.rs

@@ -1,1 +52,78 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:398 */
    2      3   
pub(crate) fn de_con_b_list_inner<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained>,
    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::StartArray { .. }) => {
          22  +
            /* JsonParserGenerator.kt:407 */
   19     23   
            let mut items = Vec::new();
          24  +
            /* JsonParserGenerator.kt:408 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:409 */
   21     27   
                match tokens.peek() {
          28  +
                    /* JsonParserGenerator.kt:410 */
   22     29   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          30  +
                        /* JsonParserGenerator.kt:411 */
   23     31   
                        tokens.next().transpose().unwrap();
   24     32   
                        break;
          33  +
                        /* JsonParserGenerator.kt:410 */
   25     34   
                    }
          35  +
                    /* JsonParserGenerator.kt:413 */
   26     36   
                    _ => {
   27         -
                        let value = crate::protocol_serde::shape_con_b::de_con_b(tokens)?;
          37  +
                        /* JsonParserGenerator.kt:419 */
          38  +
                        let value =
          39  +
                            /* JsonParserGenerator.kt:544 */crate::protocol_serde::shape_con_b::de_con_b(tokens)?
          40  +
                        /* JsonParserGenerator.kt:419 */;
          41  +
                        /* JsonParserGenerator.kt:422 */
   28     42   
                        if let Some(value) = value {
   29     43   
                            items.push(value);
   30         -
                        } else {
          44  +
                        }
          45  +
                        /* JsonParserGenerator.kt:430 */
          46  +
                        else {
   31     47   
                            return Err(
   32     48   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   33     49   
                                    "dense list cannot contain null values",
   34     50   
                                ),
   35     51   
                            );
   36     52   
                        }
          53  +
                        /* JsonParserGenerator.kt:413 */
          54  +
                    } /* JsonParserGenerator.kt:409 */
   37     55   
                }
          56  +
                /* JsonParserGenerator.kt:408 */
   38     57   
            }
   39         -
            }
          58  +
            /* JsonParserGenerator.kt:444 */
   40     59   
            Ok(Some(
   41     60   
                crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained(
   42     61   
                    items,
   43     62   
                ),
   44     63   
            ))
          64  +
            /* JsonParserGenerator.kt:713 */
   45     65   
        }
   46         -
        _ => Err(
          66  +
        /* JsonParserGenerator.kt:722 */
          67  +
        _ => {
          68  +
            /* JsonParserGenerator.kt:723 */
          69  +
            Err(
   47     70   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   48     71   
                    "expected start array or null",
   49     72   
                ),
   50         -
        ),
          73  +
            )
          74  +
            /* JsonParserGenerator.kt:722 */
          75  +
        } /* JsonParserGenerator.kt:712 */
   51     76   
    }
          77  +
    /* JsonParserGenerator.kt:398 */
   52     78   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_con_b_map.rs

@@ -1,1 +62,89 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:460 */
    2      3   
pub(crate) fn de_con_b_map<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::con_b_map_unconstrained::ConBMapUnconstrained>,
    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  +
            /* JsonParserGenerator.kt:469 */
   19     23   
            let mut map = ::std::collections::HashMap::new();
          24  +
            /* JsonParserGenerator.kt:684 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:685 */
   21     27   
                match tokens.next().transpose()? {
          28  +
                    /* JsonParserGenerator.kt:686 */
   22     29   
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
   23     30   
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
   24         -
                        let key = key.to_unescaped().map(|u| u.into_owned())?;
   25         -
                        let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
   26         -
                            tokens.next(),
   27         -
                        )?
   28         -
                        .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   29         -
                        .transpose()?;
          31  +
                        /* JsonParserGenerator.kt:471 */
          32  +
                        let key =
          33  +
                            /* JsonParserGenerator.kt:339 */key.to_unescaped().map(|u|
          34  +
                                /* JsonParserGenerator.kt:348 */u.into_owned()
          35  +
                            /* JsonParserGenerator.kt:339 */)
          36  +
                        /* JsonParserGenerator.kt:471 */?;
          37  +
                        /* JsonParserGenerator.kt:474 */
          38  +
                        let value =
          39  +
                            /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          40  +
                                /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          41  +
                                    /* JsonParserGenerator.kt:348 */u.into_owned()
          42  +
                                /* JsonParserGenerator.kt:339 */)
          43  +
                            /* JsonParserGenerator.kt:354 */).transpose()?
          44  +
                        /* JsonParserGenerator.kt:474 */;
          45  +
                        /* JsonParserGenerator.kt:481 */
   30     46   
                        match value {
   31     47   
                            Some(value) => {
   32     48   
                                map.insert(key, value);
   33     49   
                            }
   34     50   
                            None => {
   35     51   
                                return Err(
   36     52   
                                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   37     53   
                                        "dense map cannot contain null values",
   38     54   
                                    ),
   39     55   
                                )
   40     56   
                            }
   41     57   
                        }
          58  +
                        /* JsonParserGenerator.kt:686 */
   42     59   
                    }
          60  +
                    /* JsonParserGenerator.kt:695 */
   43     61   
                    other => {
   44     62   
                        return Err(
   45     63   
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   46     64   
                                format!("expected object key or end object, found: {:?}", other),
   47     65   
                            ),
   48     66   
                        )
          67  +
                    } /* JsonParserGenerator.kt:685 */
   49     68   
                }
          69  +
                /* JsonParserGenerator.kt:684 */
   50     70   
            }
   51         -
            }
          71  +
            /* JsonParserGenerator.kt:502 */
   52     72   
            Ok(Some(
   53     73   
                crate::unconstrained::con_b_map_unconstrained::ConBMapUnconstrained(map),
   54     74   
            ))
          75  +
            /* JsonParserGenerator.kt:713 */
   55     76   
        }
   56         -
        _ => Err(
          77  +
        /* JsonParserGenerator.kt:722 */
          78  +
        _ => {
          79  +
            /* JsonParserGenerator.kt:723 */
          80  +
            Err(
   57     81   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   58     82   
                    "expected start object or null",
   59     83   
                ),
   60         -
        ),
          84  +
            )
          85  +
            /* JsonParserGenerator.kt:722 */
          86  +
        } /* JsonParserGenerator.kt:712 */
   61     87   
    }
          88  +
    /* JsonParserGenerator.kt:460 */
   62     89   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_con_b_set.rs

@@ -1,1 +53,76 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:398 */
    2      3   
pub(crate) fn de_con_b_set<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::con_b_set_unconstrained::ConBSetUnconstrained>,
    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::StartArray { .. }) => {
          22  +
            /* JsonParserGenerator.kt:407 */
   19     23   
            let mut items = Vec::new();
          24  +
            /* JsonParserGenerator.kt:408 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:409 */
   21     27   
                match tokens.peek() {
          28  +
                    /* JsonParserGenerator.kt:410 */
   22     29   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          30  +
                        /* JsonParserGenerator.kt:411 */
   23     31   
                        tokens.next().transpose().unwrap();
   24     32   
                        break;
          33  +
                        /* JsonParserGenerator.kt:410 */
   25     34   
                    }
          35  +
                    /* JsonParserGenerator.kt:413 */
   26     36   
                    _ => {
          37  +
                        /* JsonParserGenerator.kt:419 */
   27     38   
                        let value =
   28         -
                            crate::protocol_serde::shape_con_b_set_inner::de_con_b_set_inner(
   29         -
                                tokens,
   30         -
                            )?;
          39  +
                            /* JsonParserGenerator.kt:451 */crate::protocol_serde::shape_con_b_set_inner::de_con_b_set_inner(tokens)?
          40  +
                        /* JsonParserGenerator.kt:419 */;
          41  +
                        /* JsonParserGenerator.kt:422 */
   31     42   
                        if let Some(value) = value {
   32     43   
                            items.push(value);
   33         -
                        } else {
          44  +
                        }
          45  +
                        /* JsonParserGenerator.kt:430 */
          46  +
                        else {
   34     47   
                            return Err(
   35     48   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   36     49   
                                    "dense list cannot contain null values",
   37     50   
                                ),
   38     51   
                            );
   39     52   
                        }
          53  +
                        /* JsonParserGenerator.kt:413 */
          54  +
                    } /* JsonParserGenerator.kt:409 */
   40     55   
                }
          56  +
                /* JsonParserGenerator.kt:408 */
   41     57   
            }
   42         -
            }
          58  +
            /* JsonParserGenerator.kt:444 */
   43     59   
            Ok(Some(
   44     60   
                crate::unconstrained::con_b_set_unconstrained::ConBSetUnconstrained(items),
   45     61   
            ))
          62  +
            /* JsonParserGenerator.kt:713 */
   46     63   
        }
   47         -
        _ => Err(
          64  +
        /* JsonParserGenerator.kt:722 */
          65  +
        _ => {
          66  +
            /* JsonParserGenerator.kt:723 */
          67  +
            Err(
   48     68   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   49     69   
                    "expected start array or null",
   50     70   
                ),
   51         -
        ),
          71  +
            )
          72  +
            /* JsonParserGenerator.kt:722 */
          73  +
        } /* JsonParserGenerator.kt:712 */
   52     74   
    }
          75  +
    /* JsonParserGenerator.kt:398 */
   53     76   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_con_b_set_inner.rs

@@ -1,1 +56,82 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:398 */
    2      3   
pub(crate) fn de_con_b_set_inner<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::con_b_set_inner_unconstrained::ConBSetInnerUnconstrained>,
    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::StartArray { .. }) => {
          22  +
            /* JsonParserGenerator.kt:407 */
   19     23   
            let mut items = Vec::new();
          24  +
            /* JsonParserGenerator.kt:408 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:409 */
   21     27   
                match tokens.peek() {
          28  +
                    /* JsonParserGenerator.kt:410 */
   22     29   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          30  +
                        /* JsonParserGenerator.kt:411 */
   23     31   
                        tokens.next().transpose().unwrap();
   24     32   
                        break;
          33  +
                        /* JsonParserGenerator.kt:410 */
   25     34   
                    }
          35  +
                    /* JsonParserGenerator.kt:413 */
   26     36   
                    _ => {
   27         -
                        let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
   28         -
                            tokens.next(),
   29         -
                        )?
   30         -
                        .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   31         -
                        .transpose()?;
          37  +
                        /* JsonParserGenerator.kt:419 */
          38  +
                        let value =
          39  +
                            /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          40  +
                                /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          41  +
                                    /* JsonParserGenerator.kt:348 */u.into_owned()
          42  +
                                /* JsonParserGenerator.kt:339 */)
          43  +
                            /* JsonParserGenerator.kt:354 */).transpose()?
          44  +
                        /* JsonParserGenerator.kt:419 */;
          45  +
                        /* JsonParserGenerator.kt:422 */
   32     46   
                        if let Some(value) = value {
   33     47   
                            items.push(value);
   34         -
                        } else {
          48  +
                        }
          49  +
                        /* JsonParserGenerator.kt:430 */
          50  +
                        else {
   35     51   
                            return Err(
   36     52   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   37     53   
                                    "dense list cannot contain null values",
   38     54   
                                ),
   39     55   
                            );
   40     56   
                        }
          57  +
                        /* JsonParserGenerator.kt:413 */
          58  +
                    } /* JsonParserGenerator.kt:409 */
   41     59   
                }
          60  +
                /* JsonParserGenerator.kt:408 */
   42     61   
            }
   43         -
            }
          62  +
            /* JsonParserGenerator.kt:444 */
   44     63   
            Ok(Some(
   45     64   
                crate::unconstrained::con_b_set_inner_unconstrained::ConBSetInnerUnconstrained(
   46     65   
                    items,
   47     66   
                ),
   48     67   
            ))
          68  +
            /* JsonParserGenerator.kt:713 */
   49     69   
        }
   50         -
        _ => Err(
          70  +
        /* JsonParserGenerator.kt:722 */
          71  +
        _ => {
          72  +
            /* JsonParserGenerator.kt:723 */
          73  +
            Err(
   51     74   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   52     75   
                    "expected start array or null",
   53     76   
                ),
   54         -
        ),
          77  +
            )
          78  +
            /* JsonParserGenerator.kt:722 */
          79  +
        } /* JsonParserGenerator.kt:712 */
   55     80   
    }
          81  +
    /* JsonParserGenerator.kt:398 */
   56     82   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_constrained_http_bound_shapes_operation.rs

@@ -1,1 +758,1093 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* RustType.kt:516 */
    2      3   
#[allow(clippy::unnecessary_wraps)]
           4  +
/* ServerHttpBoundProtocolGenerator.kt:383 */
    3      5   
pub async fn de_constrained_http_bound_shapes_operation_http_request<B>(
    4      6   
    #[allow(unused_variables)] request: ::http::Request<B>,
    5      7   
) -> std::result::Result<
    6      8   
    crate::input::ConstrainedHttpBoundShapesOperationInput,
    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:399 */
   15     18   
    Ok({
          19  +
        /* RustType.kt:516 */
   16     20   
        #[allow(unused_mut)]
          21  +
        /* ServerHttpBoundProtocolGenerator.kt:723 */
   17     22   
        let mut input =
   18     23   
            crate::input::constrained_http_bound_shapes_operation_input::Builder::default();
          24  +
        /* RustType.kt:516 */
   19     25   
        #[allow(unused_variables)]
          26  +
        /* ServerHttpBoundProtocolGenerator.kt:728 */
   20     27   
        let ::aws_smithy_runtime_api::http::RequestParts {
   21     28   
            uri, headers, body, ..
   22     29   
        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
          30  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   23     31   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_list_pattern_string_header_header(&headers)? {
   24     32   
                                input = input.set_length_list_pattern_string_header(Some(value))
   25     33   
                            }
          34  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   26     35   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_set_pattern_string_header_header(&headers)? {
   27     36   
                                input = input.set_length_set_pattern_string_header(Some(value))
   28     37   
                            }
          38  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   29     39   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_string_header_header(&headers)? {
   30     40   
                                input = input.set_length_string_header(Some(value))
   31     41   
                            }
          42  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   32     43   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_string_header_map_prefix_header(&headers)? {
   33     44   
                                input = input.set_length_string_header_map(value)
   34     45   
                            }
          46  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   35     47   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_string_set_header_header(&headers)? {
   36     48   
                                input = input.set_length_string_set_header(Some(value))
   37     49   
                            }
          50  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   38     51   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_list_length_string_header_header(&headers)? {
   39     52   
                                input = input.set_list_length_string_header(Some(value))
   40     53   
                            }
          54  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   41     55   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_byte_header_header(&headers)? {
   42     56   
                                input = input.set_range_byte_header(value)
   43     57   
                            }
          58  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   44     59   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_byte_list_header_header(&headers)? {
   45     60   
                                input = input.set_range_byte_list_header(Some(value))
   46     61   
                            }
          62  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   47     63   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_byte_set_header_header(&headers)? {
   48     64   
                                input = input.set_range_byte_set_header(Some(value))
   49     65   
                            }
          66  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   50     67   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_integer_header_header(&headers)? {
   51     68   
                                input = input.set_range_integer_header(value)
   52     69   
                            }
          70  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   53     71   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_integer_list_header_header(&headers)? {
   54     72   
                                input = input.set_range_integer_list_header(Some(value))
   55     73   
                            }
          74  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   56     75   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_integer_set_header_header(&headers)? {
   57     76   
                                input = input.set_range_integer_set_header(Some(value))
   58     77   
                            }
          78  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   59     79   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_long_header_header(&headers)? {
   60     80   
                                input = input.set_range_long_header(value)
   61     81   
                            }
          82  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   62     83   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_long_list_header_header(&headers)? {
   63     84   
                                input = input.set_range_long_list_header(Some(value))
   64     85   
                            }
          86  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   65     87   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_long_set_header_header(&headers)? {
   66     88   
                                input = input.set_range_long_set_header(Some(value))
   67     89   
                            }
          90  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   68     91   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_short_header_header(&headers)? {
   69     92   
                                input = input.set_range_short_header(value)
   70     93   
                            }
          94  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   71     95   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_short_list_header_header(&headers)? {
   72     96   
                                input = input.set_range_short_list_header(Some(value))
   73     97   
                            }
          98  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   74     99   
        if let Some(value) = crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_short_set_header_header(&headers)? {
   75    100   
                                input = input.set_range_short_set_header(Some(value))
   76    101   
                            }
         102  +
        /* ServerHttpBoundProtocolGenerator.kt:986 */
   77    103   
        let input_string = uri.path();
         104  +
        /* ServerHttpBoundProtocolGenerator.kt:998 */
   78    105   
        let (input_string, (_, m1, m2, m3, m4, m5, m6)) =
   79    106   
            ::nom::sequence::tuple::<_, _, ::nom::error::Error<&str>, _>((
   80    107   
                ::nom::sequence::preceded(
   81    108   
                    ::nom::bytes::complete::tag("/"),
   82    109   
                    ::nom::bytes::complete::tag::<_, _, ::nom::error::Error<&str>>(
   83    110   
                        "constrained-http-bound-shapes-operation",
   84    111   
                    ),
   85    112   
                ),
   86    113   
                ::nom::sequence::preceded(
   87    114   
                    ::nom::bytes::complete::tag("/"),
   88    115   
                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
   89    116   
                        ::nom::bytes::complete::take_until("/"),
   90    117   
                        ::nom::combinator::rest,
   91    118   
                    )),
   92    119   
                ),
   93    120   
                ::nom::sequence::preceded(
   94    121   
                    ::nom::bytes::complete::tag("/"),
   95    122   
                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
   96    123   
                        ::nom::bytes::complete::take_until("/"),
   97    124   
                        ::nom::combinator::rest,
   98    125   
                    )),
   99    126   
                ),
  100    127   
                ::nom::sequence::preceded(
  101    128   
                    ::nom::bytes::complete::tag("/"),
  102    129   
                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
  103    130   
                        ::nom::bytes::complete::take_until("/"),
  104    131   
                        ::nom::combinator::rest,
  105    132   
                    )),
  106    133   
                ),
  107    134   
                ::nom::sequence::preceded(
  108    135   
                    ::nom::bytes::complete::tag("/"),
  109    136   
                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
  110    137   
                        ::nom::bytes::complete::take_until("/"),
  111    138   
                        ::nom::combinator::rest,
  112    139   
                    )),
  113    140   
                ),
  114    141   
                ::nom::sequence::preceded(
  115    142   
                    ::nom::bytes::complete::tag("/"),
  116    143   
                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
  117    144   
                        ::nom::bytes::complete::take_until("/"),
  118    145   
                        ::nom::combinator::rest,
  119    146   
                    )),
  120    147   
                ),
  121    148   
                ::nom::sequence::preceded(
  122    149   
                    ::nom::bytes::complete::tag("/"),
  123    150   
                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
  124    151   
                        ::nom::bytes::complete::take_until("/"),
  125    152   
                        ::nom::combinator::rest,
  126    153   
                    )),
  127    154   
                ),
  128    155   
            ))(input_string)?;
  129    156   
        debug_assert_eq!("", input_string);
         157  +
        /* ServerHttpBoundProtocolGenerator.kt:1009 */
  130    158   
        input = input.set_range_integer_label(
  131    159   
                                        crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_integer_label(m1)?
  132    160   
                                    );
         161  +
        /* ServerHttpBoundProtocolGenerator.kt:1009 */
  133    162   
        input = input.set_range_short_label(
  134    163   
                                        crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_short_label(m2)?
  135    164   
                                    );
         165  +
        /* ServerHttpBoundProtocolGenerator.kt:1009 */
  136    166   
        input = input.set_range_long_label(
  137    167   
                                        crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_long_label(m3)?
  138    168   
                                    );
         169  +
        /* ServerHttpBoundProtocolGenerator.kt:1009 */
  139    170   
        input = input.set_range_byte_label(
  140    171   
                                        crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_byte_label(m4)?
  141    172   
                                    );
         173  +
        /* ServerHttpBoundProtocolGenerator.kt:1009 */
  142    174   
        input = input.set_length_string_label(
  143    175   
                                        crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_string_label(m5)?
  144    176   
                                    );
         177  +
        /* ServerHttpBoundProtocolGenerator.kt:1009 */
  145    178   
        input = input.set_enum_string_label(
  146    179   
                                        crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_enum_string_label(m6)?
  147    180   
                                    );
         181  +
        /* ServerHttpBoundProtocolGenerator.kt:1073 */
  148    182   
        let query_string = uri.query().unwrap_or("");
  149    183   
        let pairs = ::form_urlencoded::parse(query_string.as_bytes());
         184  +
        /* ServerHttpBoundProtocolGenerator.kt:1099 */
  150    185   
        let mut enum_string_query_seen = false;
         186  +
        /* ServerHttpBoundProtocolGenerator.kt:1099 */
  151    187   
        let mut length_string_query_seen = false;
         188  +
        /* ServerHttpBoundProtocolGenerator.kt:1099 */
  152    189   
        let mut range_byte_query_seen = false;
         190  +
        /* ServerHttpBoundProtocolGenerator.kt:1099 */
  153    191   
        let mut range_integer_query_seen = false;
         192  +
        /* ServerHttpBoundProtocolGenerator.kt:1099 */
  154    193   
        let mut range_long_query_seen = false;
         194  +
        /* ServerHttpBoundProtocolGenerator.kt:1099 */
  155    195   
        let mut range_short_query_seen = false;
         196  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  156    197   
        let mut enum_string_list_query = Vec::new();
         198  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  157    199   
        let mut length_list_pattern_string_query = Vec::new();
         200  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  158    201   
        let mut length_string_list_query = Vec::new();
         202  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  159    203   
        let mut length_string_set_query = Vec::new();
         204  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  160    205   
        let mut range_byte_list_query = Vec::new();
         206  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  161    207   
        let mut range_byte_set_query = Vec::new();
         208  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  162    209   
        let mut range_integer_list_query = Vec::new();
         210  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  163    211   
        let mut range_integer_set_query = Vec::new();
         212  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  164    213   
        let mut range_long_list_query = Vec::new();
         214  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  165    215   
        let mut range_long_set_query = Vec::new();
         216  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  166    217   
        let mut range_short_list_query = Vec::new();
         218  +
        /* ServerHttpBoundProtocolGenerator.kt:1102 */
  167    219   
        let mut range_short_set_query = Vec::new();
         220  +
        /* ServerHttpBoundProtocolGenerator.kt:1105 */
  168    221   
        for (k, v) in pairs {
         222  +
            /* ServerHttpBoundProtocolGenerator.kt:1109 */
  169    223   
            if !enum_string_query_seen && k == "enumString" {
  170    224   
                input = input.set_enum_string_query(
  171    225   
                    crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_enum_string_query(&v)?
  172    226   
                );
  173    227   
                enum_string_query_seen = true;
  174    228   
            }
         229  +
            /* ServerHttpBoundProtocolGenerator.kt:1109 */
  175    230   
            if !length_string_query_seen && k == "lengthString" {
  176    231   
                input = input.set_length_string_query(
  177    232   
                    crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_string_query(&v)?
  178    233   
                );
  179    234   
                length_string_query_seen = true;
  180    235   
            }
         236  +
            /* ServerHttpBoundProtocolGenerator.kt:1109 */
  181    237   
            if !range_byte_query_seen && k == "rangeByte" {
  182    238   
                input = input.set_range_byte_query(
  183    239   
                    crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_byte_query(&v)?
  184    240   
                );
  185    241   
                range_byte_query_seen = true;
  186    242   
            }
         243  +
            /* ServerHttpBoundProtocolGenerator.kt:1109 */
  187    244   
            if !range_integer_query_seen && k == "rangeInteger" {
  188    245   
                input = input.set_range_integer_query(
  189    246   
                    crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_integer_query(&v)?
  190    247   
                );
  191    248   
                range_integer_query_seen = true;
  192    249   
            }
         250  +
            /* ServerHttpBoundProtocolGenerator.kt:1109 */
  193    251   
            if !range_long_query_seen && k == "rangeLong" {
  194    252   
                input = input.set_range_long_query(
  195    253   
                    crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_long_query(&v)?
  196    254   
                );
  197    255   
                range_long_query_seen = true;
  198    256   
            }
         257  +
            /* ServerHttpBoundProtocolGenerator.kt:1109 */
  199    258   
            if !range_short_query_seen && k == "rangeShort" {
  200    259   
                input = input.set_range_short_query(
  201    260   
                    crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_range_short_query(&v)?
  202    261   
                );
  203    262   
                range_short_query_seen = true;
  204    263   
            }
         264  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
  205    265   
            if k == "enumStringList" {
         266  +
                /* ServerHttpBoundProtocolGenerator.kt:1134 */
  206    267   
                let v = v.into_owned();
         268  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  207    269   
                enum_string_list_query.push(v);
  208         -
            } else if k == "lengthListPatternString" {
         270  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         271  +
            }
         272  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         273  +
            else if k == "lengthListPatternString" {
         274  +
                /* ServerHttpBoundProtocolGenerator.kt:1134 */
  209    275   
                let v = v.into_owned();
         276  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  210    277   
                length_list_pattern_string_query.push(v);
  211         -
            } else if k == "lengthStringList" {
         278  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         279  +
            }
         280  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         281  +
            else if k == "lengthStringList" {
         282  +
                /* ServerHttpBoundProtocolGenerator.kt:1134 */
  212    283   
                let v = v.into_owned();
         284  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  213    285   
                length_string_list_query.push(v);
  214         -
            } else if k == "lengthStringSet" {
         286  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         287  +
            }
         288  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         289  +
            else if k == "lengthStringSet" {
         290  +
                /* ServerHttpBoundProtocolGenerator.kt:1134 */
  215    291   
                let v = v.into_owned();
         292  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  216    293   
                length_string_set_query.push(v);
  217         -
            } else if k == "rangeByteList" {
         294  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         295  +
            }
         296  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         297  +
            else if k == "rangeByteList" {
         298  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  218    299   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         300  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  219    301   
                range_byte_list_query.push(v);
  220         -
            } else if k == "rangeByteSet" {
         302  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         303  +
            }
         304  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         305  +
            else if k == "rangeByteSet" {
         306  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  221    307   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         308  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  222    309   
                range_byte_set_query.push(v);
  223         -
            } else if k == "rangeIntegerList" {
         310  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         311  +
            }
         312  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         313  +
            else if k == "rangeIntegerList" {
         314  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  224    315   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         316  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  225    317   
                range_integer_list_query.push(v);
  226         -
            } else if k == "rangeIntegerSet" {
         318  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         319  +
            }
         320  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         321  +
            else if k == "rangeIntegerSet" {
         322  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  227    323   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         324  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  228    325   
                range_integer_set_query.push(v);
  229         -
            } else if k == "rangeLongList" {
         326  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         327  +
            }
         328  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         329  +
            else if k == "rangeLongList" {
         330  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  230    331   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         332  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  231    333   
                range_long_list_query.push(v);
  232         -
            } else if k == "rangeLongSet" {
         334  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         335  +
            }
         336  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         337  +
            else if k == "rangeLongSet" {
         338  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  233    339   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         340  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  234    341   
                range_long_set_query.push(v);
  235         -
            } else if k == "rangeShortList" {
         342  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         343  +
            }
         344  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         345  +
            else if k == "rangeShortList" {
         346  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  236    347   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         348  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  237    349   
                range_short_list_query.push(v);
  238         -
            } else if k == "rangeShortSet" {
         350  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         351  +
            }
         352  +
            /* ServerHttpBoundProtocolGenerator.kt:1122 */
         353  +
            else if k == "rangeShortSet" {
         354  +
                /* ServerHttpBoundProtocolGenerator.kt:1159 */
  239    355   
                let v = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(&v)?;
         356  +
                /* ServerHttpBoundProtocolGenerator.kt:1168 */
  240    357   
                range_short_set_query.push(v);
         358  +
                /* ServerHttpBoundProtocolGenerator.kt:1122 */
  241    359   
            }
         360  +
            /* ServerHttpBoundProtocolGenerator.kt:1105 */
  242    361   
        }
         362  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  243    363   
        if !enum_string_list_query.is_empty() {
         364  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  244    365   
            input = input.set_enum_string_list_query(
  245         -
                Some(
  246         -
                    crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained(
  247         -
                        enum_string_list_query
  248         -
                    )
  249         -
                )
  250         -
            );
  251         -
        }
         366  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         367  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained(
         368  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */enum_string_list_query
         369  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         370  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         371  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         372  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         373  +
        }
         374  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  252    375   
        if !length_list_pattern_string_query.is_empty() {
         376  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  253    377   
            input = input.set_length_list_pattern_string_query(
  254         -
                Some(
  255         -
                    crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained(
  256         -
                        length_list_pattern_string_query
  257         -
                    )
  258         -
                )
  259         -
            );
  260         -
        }
         378  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         379  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained(
         380  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */length_list_pattern_string_query
         381  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         382  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         383  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         384  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         385  +
        }
         386  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  261    387   
        if !length_string_list_query.is_empty() {
         388  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  262    389   
            input = input.set_length_string_list_query(
  263         -
                Some(
  264         -
                    crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained(
  265         -
                        length_string_list_query
  266         -
                    )
  267         -
                )
  268         -
            );
  269         -
        }
         390  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         391  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained(
         392  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */length_string_list_query
         393  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         394  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         395  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         396  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         397  +
        }
         398  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  270    399   
        if !length_string_set_query.is_empty() {
         400  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  271    401   
            input = input.set_length_string_set_query(
  272         -
                Some(
  273         -
                    crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained(
  274         -
                        length_string_set_query
  275         -
                    )
  276         -
                )
  277         -
            );
  278         -
        }
         402  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         403  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained(
         404  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */length_string_set_query
         405  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         406  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         407  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         408  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         409  +
        }
         410  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  279    411   
        if !range_byte_list_query.is_empty() {
         412  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  280    413   
            input = input.set_range_byte_list_query(
  281         -
                Some(
  282         -
                    crate::unconstrained::list_of_range_byte_unconstrained::ListOfRangeByteUnconstrained(
  283         -
                        range_byte_list_query
  284         -
                    )
  285         -
                )
  286         -
            );
  287         -
        }
         414  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         415  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::list_of_range_byte_unconstrained::ListOfRangeByteUnconstrained(
         416  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_byte_list_query
         417  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         418  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         419  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         420  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         421  +
        }
         422  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  288    423   
        if !range_byte_set_query.is_empty() {
  289         -
            input = input.set_range_byte_set_query(Some(
  290         -
                crate::unconstrained::set_of_range_byte_unconstrained::SetOfRangeByteUnconstrained(
  291         -
                    range_byte_set_query,
  292         -
                ),
  293         -
            ));
  294         -
        }
         424  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
         425  +
            input = input.set_range_byte_set_query(
         426  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         427  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::set_of_range_byte_unconstrained::SetOfRangeByteUnconstrained(
         428  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_byte_set_query
         429  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         430  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         431  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         432  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         433  +
        }
         434  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  295    435   
        if !range_integer_list_query.is_empty() {
         436  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  296    437   
            input = input.set_range_integer_list_query(
  297         -
                Some(
  298         -
                    crate::unconstrained::list_of_range_integer_unconstrained::ListOfRangeIntegerUnconstrained(
  299         -
                        range_integer_list_query
  300         -
                    )
  301         -
                )
  302         -
            );
  303         -
        }
         438  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         439  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::list_of_range_integer_unconstrained::ListOfRangeIntegerUnconstrained(
         440  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_integer_list_query
         441  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         442  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         443  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         444  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         445  +
        }
         446  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  304    447   
        if !range_integer_set_query.is_empty() {
         448  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  305    449   
            input = input.set_range_integer_set_query(
  306         -
                Some(
  307         -
                    crate::unconstrained::set_of_range_integer_unconstrained::SetOfRangeIntegerUnconstrained(
  308         -
                        range_integer_set_query
  309         -
                    )
  310         -
                )
  311         -
            );
  312         -
        }
         450  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         451  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::set_of_range_integer_unconstrained::SetOfRangeIntegerUnconstrained(
         452  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_integer_set_query
         453  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         454  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         455  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         456  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         457  +
        }
         458  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  313    459   
        if !range_long_list_query.is_empty() {
         460  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  314    461   
            input = input.set_range_long_list_query(
  315         -
                Some(
  316         -
                    crate::unconstrained::list_of_range_long_unconstrained::ListOfRangeLongUnconstrained(
  317         -
                        range_long_list_query
  318         -
                    )
  319         -
                )
  320         -
            );
  321         -
        }
         462  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         463  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::list_of_range_long_unconstrained::ListOfRangeLongUnconstrained(
         464  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_long_list_query
         465  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         466  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         467  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         468  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         469  +
        }
         470  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  322    471   
        if !range_long_set_query.is_empty() {
  323         -
            input = input.set_range_long_set_query(Some(
  324         -
                crate::unconstrained::set_of_range_long_unconstrained::SetOfRangeLongUnconstrained(
  325         -
                    range_long_set_query,
  326         -
                ),
  327         -
            ));
  328         -
        }
         472  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
         473  +
            input = input.set_range_long_set_query(
         474  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         475  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::set_of_range_long_unconstrained::SetOfRangeLongUnconstrained(
         476  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_long_set_query
         477  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         478  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         479  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         480  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         481  +
        }
         482  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  329    483   
        if !range_short_list_query.is_empty() {
         484  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  330    485   
            input = input.set_range_short_list_query(
  331         -
                Some(
  332         -
                    crate::unconstrained::list_of_range_short_unconstrained::ListOfRangeShortUnconstrained(
  333         -
                        range_short_list_query
  334         -
                    )
  335         -
                )
  336         -
            );
  337         -
        }
         486  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         487  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::list_of_range_short_unconstrained::ListOfRangeShortUnconstrained(
         488  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_short_list_query
         489  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         490  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         491  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         492  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         493  +
        }
         494  +
        /* ServerHttpBoundProtocolGenerator.kt:1228 */
  338    495   
        if !range_short_set_query.is_empty() {
         496  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */
  339    497   
            input = input.set_range_short_set_query(
  340         -
                Some(
  341         -
                    crate::unconstrained::set_of_range_short_unconstrained::SetOfRangeShortUnconstrained(
  342         -
                        range_short_set_query
  343         -
                    )
  344         -
                )
  345         -
            );
  346         -
        }
         498  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */Some(
         499  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */crate::unconstrained::set_of_range_short_unconstrained::SetOfRangeShortUnconstrained(
         500  +
                        /* ServerHttpBoundProtocolGenerator.kt:1244 */range_short_set_query
         501  +
                    /* ServerHttpBoundProtocolGenerator.kt:1236 */)
         502  +
                /* ServerHttpBoundProtocolGenerator.kt:1235 */)
         503  +
            /* ServerHttpBoundProtocolGenerator.kt:1229 */);
         504  +
            /* ServerHttpBoundProtocolGenerator.kt:1228 */
         505  +
        }
         506  +
        /* ServerHttpBoundProtocolGenerator.kt:834 */
  347    507   
        input.build()?
         508  +
        /* ServerHttpBoundProtocolGenerator.kt:399 */
  348    509   
    })
         510  +
    /* ServerHttpBoundProtocolGenerator.kt:383 */
  349    511   
}
  350    512   
         513  +
/* RustType.kt:516 */
  351    514   
#[allow(clippy::unnecessary_wraps)]
         515  +
/* ServerHttpBoundProtocolGenerator.kt:421 */
  352    516   
pub fn ser_constrained_http_bound_shapes_operation_http_response(
  353    517   
    #[allow(unused_variables)] output: crate::output::ConstrainedHttpBoundShapesOperationOutput,
  354    518   
) -> std::result::Result<
  355    519   
    ::aws_smithy_http_server::response::Response,
  356    520   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
  357    521   
> {
         522  +
    /* ServerHttpBoundProtocolGenerator.kt:433 */
  358    523   
    Ok({
         524  +
        /* RustType.kt:516 */
  359    525   
        #[allow(unused_mut)]
         526  +
        /* ServerHttpBoundProtocolGenerator.kt:523 */
  360    527   
        let mut builder = ::http::Response::builder();
         528  +
        /* ServerHttpBoundProtocolGenerator.kt:629 */
  361    529   
        builder = crate::protocol_serde::shape_constrained_http_bound_shapes_operation::ser_constrained_http_bound_shapes_operation_headers(&output, builder)?;
         530  +
        /* ServerHttpBoundProtocolGenerator.kt:597 */
  362    531   
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
  363    532   
            builder,
  364    533   
            ::http::header::CONTENT_TYPE,
  365    534   
            "application/json",
  366    535   
        );
         536  +
        /* ServerHttpBoundProtocolGenerator.kt:682 */
  367    537   
        let http_status: u16 = 200;
  368    538   
        builder = builder.status(http_status);
         539  +
        /* ServerHttpBoundProtocolGenerator.kt:561 */
  369    540   
        let payload =
  370         -
            crate::protocol_serde::shape_constrained_http_bound_shapes_operation_output::ser_constrained_http_bound_shapes_operation_output_output_output(&output)?
  371         -
        ;
         541  +
            /* HttpBoundProtocolPayloadGenerator.kt:237 */crate::protocol_serde::shape_constrained_http_bound_shapes_operation_output::ser_constrained_http_bound_shapes_operation_output_output_output(&output)?
         542  +
        /* ServerHttpBoundProtocolGenerator.kt:561 */;
         543  +
        /* ServerHttpBoundProtocolGenerator.kt:663 */
  372    544   
        let content_length = payload.len();
  373    545   
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
  374    546   
            builder,
  375    547   
            ::http::header::CONTENT_LENGTH,
  376    548   
            content_length,
  377    549   
        );
         550  +
        /* ServerHttpBoundProtocolGenerator.kt:567 */
  378    551   
        let body = ::aws_smithy_http_server::body::to_boxed(payload);
         552  +
        /* ServerHttpBoundProtocolGenerator.kt:575 */
  379    553   
        builder.body(body)?
         554  +
        /* ServerHttpBoundProtocolGenerator.kt:433 */
  380    555   
    })
         556  +
    /* ServerHttpBoundProtocolGenerator.kt:421 */
  381    557   
}
  382    558   
         559  +
/* RustType.kt:516 */
  383    560   
#[allow(clippy::unnecessary_wraps)]
         561  +
/* ServerHttpBoundProtocolGenerator.kt:447 */
  384    562   
pub fn ser_constrained_http_bound_shapes_operation_http_error(
  385    563   
    error: &crate::error::ConstrainedHttpBoundShapesOperationError,
  386    564   
) -> std::result::Result<
  387    565   
    ::aws_smithy_http_server::response::Response,
  388    566   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
  389    567   
> {
         568  +
    /* ServerHttpBoundProtocolGenerator.kt:452 */
  390    569   
    Ok({
         570  +
        /* ServerHttpBoundProtocolGenerator.kt:468 */
  391    571   
        match error {
         572  +
            /* ServerHttpBoundProtocolGenerator.kt:476 */
  392    573   
            crate::error::ConstrainedHttpBoundShapesOperationError::ValidationException(output) => {
         574  +
                /* ServerHttpBoundProtocolGenerator.kt:477 */
  393    575   
                let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
         576  +
                /* RustType.kt:516 */
  394    577   
                #[allow(unused_mut)]
         578  +
                /* ServerHttpBoundProtocolGenerator.kt:487 */
  395    579   
                let mut builder = ::http::Response::builder();
         580  +
                /* ServerHttpBoundProtocolGenerator.kt:597 */
  396    581   
                builder = ::aws_smithy_http::header::set_response_header_if_absent(
  397    582   
                    builder,
  398    583   
                    ::http::header::CONTENT_TYPE,
  399    584   
                    "application/json",
  400    585   
                );
         586  +
                /* ServerHttpBoundProtocolGenerator.kt:597 */
  401    587   
                builder = ::aws_smithy_http::header::set_response_header_if_absent(
  402    588   
                    builder,
  403    589   
                    ::http::header::HeaderName::from_static("x-amzn-errortype"),
  404    590   
                    "ValidationException",
  405    591   
                );
         592  +
                /* ServerHttpBoundProtocolGenerator.kt:663 */
  406    593   
                let content_length = payload.len();
  407    594   
                builder = ::aws_smithy_http::header::set_response_header_if_absent(
  408    595   
                    builder,
  409    596   
                    ::http::header::CONTENT_LENGTH,
  410    597   
                    content_length,
  411    598   
                );
         599  +
                /* ServerHttpBoundProtocolGenerator.kt:504 */
  412    600   
                builder
  413    601   
                    .status(400)
  414    602   
                    .body(::aws_smithy_http_server::body::to_boxed(payload))?
         603  +
                /* ServerHttpBoundProtocolGenerator.kt:476 */
         604  +
            } /* ServerHttpBoundProtocolGenerator.kt:468 */
  415    605   
        }
  416         -
        }
         606  +
        /* ServerHttpBoundProtocolGenerator.kt:452 */
  417    607   
    })
         608  +
    /* ServerHttpBoundProtocolGenerator.kt:447 */
  418    609   
}
  419    610   
         611  +
/* HttpBindingGenerator.kt:542 */
  420    612   
pub fn ser_constrained_http_bound_shapes_operation_headers(
  421    613   
    input: &crate::output::ConstrainedHttpBoundShapesOperationOutput,
  422    614   
    mut builder: ::http::response::Builder,
  423    615   
) -> std::result::Result<::http::response::Builder, ::aws_smithy_types::error::operation::BuildError>
  424    616   
{
         617  +
    /* HttpBindingGenerator.kt:592 */
  425    618   
    if let ::std::option::Option::Some(inner_1) = &input.length_string_header {
         619  +
        /* HttpBindingGenerator.kt:704 */
  426    620   
        let formatted_2 = inner_1.as_str();
         621  +
        /* HttpBindingGenerator.kt:705 */
  427    622   
        if !formatted_2.is_empty() {
         623  +
            /* HttpBindingGenerator.kt:706 */
  428    624   
            let header_value = formatted_2;
  429    625   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  430    626   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  431    627   
                    "length_string_header",
  432    628   
                    format!(
  433    629   
                        "`{}` cannot be used as a header value: {}",
  434    630   
                        &header_value, err
  435    631   
                    ),
  436    632   
                )
  437    633   
            })?;
  438    634   
            builder = builder.header("X-Length", header_value);
         635  +
            /* HttpBindingGenerator.kt:705 */
  439    636   
        }
         637  +
        /* HttpBindingGenerator.kt:592 */
  440    638   
    }
         639  +
    /* SerializerUtil.kt:46 */
  441    640   
    {
         641  +
        /* HttpBindingGenerator.kt:690 */
  442    642   
        let mut encoder =
  443    643   
            ::aws_smithy_types::primitive::Encoder::from(input.range_integer_header.0);
         644  +
        /* HttpBindingGenerator.kt:704 */
  444    645   
        let formatted_3 = encoder.encode();
         646  +
        /* HttpBindingGenerator.kt:705 */
  445    647   
        if !formatted_3.is_empty() {
         648  +
            /* HttpBindingGenerator.kt:706 */
  446    649   
            let header_value = formatted_3;
  447    650   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  448    651   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  449    652   
                    "range_integer_header",
  450    653   
                    format!(
  451    654   
                        "`{}` cannot be used as a header value: {}",
  452    655   
                        &header_value, err
  453    656   
                    ),
  454    657   
                )
  455    658   
            })?;
  456    659   
            builder = builder.header("X-Range-Integer", header_value);
         660  +
            /* HttpBindingGenerator.kt:705 */
  457    661   
        }
         662  +
        /* SerializerUtil.kt:46 */
  458    663   
    }
         664  +
    /* SerializerUtil.kt:46 */
  459    665   
    {
         666  +
        /* HttpBindingGenerator.kt:690 */
  460    667   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(input.range_short_header.0);
         668  +
        /* HttpBindingGenerator.kt:704 */
  461    669   
        let formatted_4 = encoder.encode();
         670  +
        /* HttpBindingGenerator.kt:705 */
  462    671   
        if !formatted_4.is_empty() {
         672  +
            /* HttpBindingGenerator.kt:706 */
  463    673   
            let header_value = formatted_4;
  464    674   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  465    675   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  466    676   
                    "range_short_header",
  467    677   
                    format!(
  468    678   
                        "`{}` cannot be used as a header value: {}",
  469    679   
                        &header_value, err
  470    680   
                    ),
  471    681   
                )
  472    682   
            })?;
  473    683   
            builder = builder.header("X-Range-Short", header_value);
         684  +
            /* HttpBindingGenerator.kt:705 */
  474    685   
        }
         686  +
        /* SerializerUtil.kt:46 */
  475    687   
    }
         688  +
    /* SerializerUtil.kt:46 */
  476    689   
    {
         690  +
        /* HttpBindingGenerator.kt:690 */
  477    691   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(input.range_long_header.0);
         692  +
        /* HttpBindingGenerator.kt:704 */
  478    693   
        let formatted_5 = encoder.encode();
         694  +
        /* HttpBindingGenerator.kt:705 */
  479    695   
        if !formatted_5.is_empty() {
         696  +
            /* HttpBindingGenerator.kt:706 */
  480    697   
            let header_value = formatted_5;
  481    698   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  482    699   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  483    700   
                    "range_long_header",
  484    701   
                    format!(
  485    702   
                        "`{}` cannot be used as a header value: {}",
  486    703   
                        &header_value, err
  487    704   
                    ),
  488    705   
                )
  489    706   
            })?;
  490    707   
            builder = builder.header("X-Range-Long", header_value);
         708  +
            /* HttpBindingGenerator.kt:705 */
  491    709   
        }
         710  +
        /* SerializerUtil.kt:46 */
  492    711   
    }
         712  +
    /* SerializerUtil.kt:46 */
  493    713   
    {
         714  +
        /* HttpBindingGenerator.kt:690 */
  494    715   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(input.range_byte_header.0);
         716  +
        /* HttpBindingGenerator.kt:704 */
  495    717   
        let formatted_6 = encoder.encode();
         718  +
        /* HttpBindingGenerator.kt:705 */
  496    719   
        if !formatted_6.is_empty() {
         720  +
            /* HttpBindingGenerator.kt:706 */
  497    721   
            let header_value = formatted_6;
  498    722   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  499    723   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  500    724   
                    "range_byte_header",
  501    725   
                    format!(
  502    726   
                        "`{}` cannot be used as a header value: {}",
  503    727   
                        &header_value, err
  504    728   
                    ),
  505    729   
                )
  506    730   
            })?;
  507    731   
            builder = builder.header("X-Range-Byte", header_value);
         732  +
            /* HttpBindingGenerator.kt:705 */
  508    733   
        }
         734  +
        /* SerializerUtil.kt:46 */
  509    735   
    }
         736  +
    /* HttpBindingGenerator.kt:592 */
  510    737   
    if let ::std::option::Option::Some(inner_7) = &input.length_string_set_header {
         738  +
        /* HttpBindingGenerator.kt:646 */
  511    739   
        for inner_8 in &inner_7.0 {
         740  +
            /* HttpBindingGenerator.kt:704 */
  512    741   
            let formatted_9 = ::aws_smithy_http::header::quote_header_value(inner_8.as_str());
         742  +
            /* HttpBindingGenerator.kt:705 */
  513    743   
            if !formatted_9.is_empty() {
         744  +
                /* HttpBindingGenerator.kt:706 */
  514    745   
                let header_value = formatted_9;
  515    746   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  516    747   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  517    748   
                        "length_string_set_header",
  518    749   
                        format!(
  519    750   
                            "`{}` cannot be used as a header value: {}",
  520    751   
                            &header_value, err
  521    752   
                        ),
  522    753   
                    )
  523    754   
                })?;
  524    755   
                builder = builder.header("X-Length-Set", header_value);
         756  +
                /* HttpBindingGenerator.kt:705 */
  525    757   
            }
         758  +
            /* HttpBindingGenerator.kt:646 */
  526    759   
        }
         760  +
        /* HttpBindingGenerator.kt:592 */
  527    761   
    }
         762  +
    /* HttpBindingGenerator.kt:592 */
  528    763   
    if let ::std::option::Option::Some(inner_10) = &input.list_length_string_header {
         764  +
        /* HttpBindingGenerator.kt:646 */
  529    765   
        for inner_11 in inner_10 {
         766  +
            /* HttpBindingGenerator.kt:704 */
  530    767   
            let formatted_12 = ::aws_smithy_http::header::quote_header_value(inner_11.as_str());
         768  +
            /* HttpBindingGenerator.kt:705 */
  531    769   
            if !formatted_12.is_empty() {
         770  +
                /* HttpBindingGenerator.kt:706 */
  532    771   
                let header_value = formatted_12;
  533    772   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  534    773   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  535    774   
                        "list_length_string_header",
  536    775   
                        format!(
  537    776   
                            "`{}` cannot be used as a header value: {}",
  538    777   
                            &header_value, err
  539    778   
                        ),
  540    779   
                    )
  541    780   
                })?;
  542    781   
                builder = builder.header("X-List-Length-String", header_value);
         782  +
                /* HttpBindingGenerator.kt:705 */
  543    783   
            }
         784  +
            /* HttpBindingGenerator.kt:646 */
  544    785   
        }
         786  +
        /* HttpBindingGenerator.kt:592 */
  545    787   
    }
         788  +
    /* HttpBindingGenerator.kt:592 */
  546    789   
    if let ::std::option::Option::Some(inner_13) = &input.length_list_pattern_string_header {
         790  +
        /* HttpBindingGenerator.kt:646 */
  547    791   
        for inner_14 in &inner_13.0 {
         792  +
            /* HttpBindingGenerator.kt:704 */
  548    793   
            let formatted_15 = ::aws_smithy_http::header::quote_header_value(inner_14.as_str());
         794  +
            /* HttpBindingGenerator.kt:705 */
  549    795   
            if !formatted_15.is_empty() {
         796  +
                /* HttpBindingGenerator.kt:706 */
  550    797   
                let header_value = formatted_15;
  551    798   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  552    799   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  553    800   
                        "length_list_pattern_string_header",
  554    801   
                        format!(
  555    802   
                            "`{}` cannot be used as a header value: {}",
  556    803   
                            &header_value, err
  557    804   
                        ),
  558    805   
                    )
  559    806   
                })?;
  560    807   
                builder = builder.header("X-Length-List-Pattern-String", header_value);
         808  +
                /* HttpBindingGenerator.kt:705 */
  561    809   
            }
         810  +
            /* HttpBindingGenerator.kt:646 */
  562    811   
        }
         812  +
        /* HttpBindingGenerator.kt:592 */
  563    813   
    }
         814  +
    /* HttpBindingGenerator.kt:592 */
  564    815   
    if let ::std::option::Option::Some(inner_16) = &input.length_set_pattern_string_header {
         816  +
        /* HttpBindingGenerator.kt:646 */
  565    817   
        for inner_17 in &inner_16.0 {
         818  +
            /* HttpBindingGenerator.kt:704 */
  566    819   
            let formatted_18 = ::aws_smithy_http::header::quote_header_value(inner_17.as_str());
         820  +
            /* HttpBindingGenerator.kt:705 */
  567    821   
            if !formatted_18.is_empty() {
         822  +
                /* HttpBindingGenerator.kt:706 */
  568    823   
                let header_value = formatted_18;
  569    824   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  570    825   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  571    826   
                        "length_set_pattern_string_header",
  572    827   
                        format!(
  573    828   
                            "`{}` cannot be used as a header value: {}",
  574    829   
                            &header_value, err
  575    830   
                        ),
  576    831   
                    )
  577    832   
                })?;
  578    833   
                builder = builder.header("X-Length-Set-Pattern-String", header_value);
         834  +
                /* HttpBindingGenerator.kt:705 */
  579    835   
            }
         836  +
            /* HttpBindingGenerator.kt:646 */
  580    837   
        }
         838  +
        /* HttpBindingGenerator.kt:592 */
  581    839   
    }
         840  +
    /* HttpBindingGenerator.kt:592 */
  582    841   
    if let ::std::option::Option::Some(inner_19) = &input.range_byte_set_header {
         842  +
        /* HttpBindingGenerator.kt:646 */
  583    843   
        for inner_20 in &inner_19.0 {
         844  +
            /* HttpBindingGenerator.kt:690 */
  584    845   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_20.0);
         846  +
            /* HttpBindingGenerator.kt:704 */
  585    847   
            let formatted_21 = encoder.encode();
         848  +
            /* HttpBindingGenerator.kt:705 */
  586    849   
            if !formatted_21.is_empty() {
         850  +
                /* HttpBindingGenerator.kt:706 */
  587    851   
                let header_value = formatted_21;
  588    852   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  589    853   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  590    854   
                        "range_byte_set_header",
  591    855   
                        format!(
  592    856   
                            "`{}` cannot be used as a header value: {}",
  593    857   
                            &header_value, err
  594    858   
                        ),
  595    859   
                    )
  596    860   
                })?;
  597    861   
                builder = builder.header("X-Range-Byte-Set", header_value);
         862  +
                /* HttpBindingGenerator.kt:705 */
  598    863   
            }
         864  +
            /* HttpBindingGenerator.kt:646 */
  599    865   
        }
         866  +
        /* HttpBindingGenerator.kt:592 */
  600    867   
    }
         868  +
    /* HttpBindingGenerator.kt:592 */
  601    869   
    if let ::std::option::Option::Some(inner_22) = &input.range_short_set_header {
         870  +
        /* HttpBindingGenerator.kt:646 */
  602    871   
        for inner_23 in &inner_22.0 {
         872  +
            /* HttpBindingGenerator.kt:690 */
  603    873   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_23.0);
         874  +
            /* HttpBindingGenerator.kt:704 */
  604    875   
            let formatted_24 = encoder.encode();
         876  +
            /* HttpBindingGenerator.kt:705 */
  605    877   
            if !formatted_24.is_empty() {
         878  +
                /* HttpBindingGenerator.kt:706 */
  606    879   
                let header_value = formatted_24;
  607    880   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  608    881   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  609    882   
                        "range_short_set_header",
  610    883   
                        format!(
  611    884   
                            "`{}` cannot be used as a header value: {}",
  612    885   
                            &header_value, err
  613    886   
                        ),
  614    887   
                    )
  615    888   
                })?;
  616    889   
                builder = builder.header("X-Range-Short-Set", header_value);
         890  +
                /* HttpBindingGenerator.kt:705 */
  617    891   
            }
         892  +
            /* HttpBindingGenerator.kt:646 */
  618    893   
        }
         894  +
        /* HttpBindingGenerator.kt:592 */
  619    895   
    }
         896  +
    /* HttpBindingGenerator.kt:592 */
  620    897   
    if let ::std::option::Option::Some(inner_25) = &input.range_integer_set_header {
         898  +
        /* HttpBindingGenerator.kt:646 */
  621    899   
        for inner_26 in &inner_25.0 {
         900  +
            /* HttpBindingGenerator.kt:690 */
  622    901   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_26.0);
         902  +
            /* HttpBindingGenerator.kt:704 */
  623    903   
            let formatted_27 = encoder.encode();
         904  +
            /* HttpBindingGenerator.kt:705 */
  624    905   
            if !formatted_27.is_empty() {
         906  +
                /* HttpBindingGenerator.kt:706 */
  625    907   
                let header_value = formatted_27;
  626    908   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  627    909   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  628    910   
                        "range_integer_set_header",
  629    911   
                        format!(
  630    912   
                            "`{}` cannot be used as a header value: {}",
  631    913   
                            &header_value, err
  632    914   
                        ),
  633    915   
                    )
  634    916   
                })?;
  635    917   
                builder = builder.header("X-Range-Integer-Set", header_value);
         918  +
                /* HttpBindingGenerator.kt:705 */
  636    919   
            }
         920  +
            /* HttpBindingGenerator.kt:646 */
  637    921   
        }
         922  +
        /* HttpBindingGenerator.kt:592 */
  638    923   
    }
         924  +
    /* HttpBindingGenerator.kt:592 */
  639    925   
    if let ::std::option::Option::Some(inner_28) = &input.range_long_set_header {
         926  +
        /* HttpBindingGenerator.kt:646 */
  640    927   
        for inner_29 in &inner_28.0 {
         928  +
            /* HttpBindingGenerator.kt:690 */
  641    929   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_29.0);
         930  +
            /* HttpBindingGenerator.kt:704 */
  642    931   
            let formatted_30 = encoder.encode();
         932  +
            /* HttpBindingGenerator.kt:705 */
  643    933   
            if !formatted_30.is_empty() {
         934  +
                /* HttpBindingGenerator.kt:706 */
  644    935   
                let header_value = formatted_30;
  645    936   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  646    937   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  647    938   
                        "range_long_set_header",
  648    939   
                        format!(
  649    940   
                            "`{}` cannot be used as a header value: {}",
  650    941   
                            &header_value, err
  651    942   
                        ),
  652    943   
                    )
  653    944   
                })?;
  654    945   
                builder = builder.header("X-Range-Long-Set", header_value);
         946  +
                /* HttpBindingGenerator.kt:705 */
  655    947   
            }
         948  +
            /* HttpBindingGenerator.kt:646 */
  656    949   
        }
         950  +
        /* HttpBindingGenerator.kt:592 */
  657    951   
    }
         952  +
    /* HttpBindingGenerator.kt:592 */
  658    953   
    if let ::std::option::Option::Some(inner_31) = &input.range_byte_list_header {
         954  +
        /* HttpBindingGenerator.kt:646 */
  659    955   
        for inner_32 in inner_31 {
         956  +
            /* HttpBindingGenerator.kt:690 */
  660    957   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_32.0);
         958  +
            /* HttpBindingGenerator.kt:704 */
  661    959   
            let formatted_33 = encoder.encode();
         960  +
            /* HttpBindingGenerator.kt:705 */
  662    961   
            if !formatted_33.is_empty() {
         962  +
                /* HttpBindingGenerator.kt:706 */
  663    963   
                let header_value = formatted_33;
  664    964   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  665    965   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  666    966   
                        "range_byte_list_header",
  667    967   
                        format!(
  668    968   
                            "`{}` cannot be used as a header value: {}",
  669    969   
                            &header_value, err
  670    970   
                        ),
  671    971   
                    )
  672    972   
                })?;
  673    973   
                builder = builder.header("X-Range-Byte-List", header_value);
         974  +
                /* HttpBindingGenerator.kt:705 */
  674    975   
            }
         976  +
            /* HttpBindingGenerator.kt:646 */
  675    977   
        }
         978  +
        /* HttpBindingGenerator.kt:592 */
  676    979   
    }
         980  +
    /* HttpBindingGenerator.kt:592 */
  677    981   
    if let ::std::option::Option::Some(inner_34) = &input.range_short_list_header {
         982  +
        /* HttpBindingGenerator.kt:646 */
  678    983   
        for inner_35 in inner_34 {
         984  +
            /* HttpBindingGenerator.kt:690 */
  679    985   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_35.0);
         986  +
            /* HttpBindingGenerator.kt:704 */
  680    987   
            let formatted_36 = encoder.encode();
         988  +
            /* HttpBindingGenerator.kt:705 */
  681    989   
            if !formatted_36.is_empty() {
         990  +
                /* HttpBindingGenerator.kt:706 */
  682    991   
                let header_value = formatted_36;
  683    992   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  684    993   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  685    994   
                        "range_short_list_header",
  686    995   
                        format!(
  687    996   
                            "`{}` cannot be used as a header value: {}",
  688    997   
                            &header_value, err
  689    998   
                        ),
  690    999   
                    )
  691   1000   
                })?;
  692   1001   
                builder = builder.header("X-Range-Short-List", header_value);
        1002  +
                /* HttpBindingGenerator.kt:705 */
  693   1003   
            }
        1004  +
            /* HttpBindingGenerator.kt:646 */
  694   1005   
        }
        1006  +
        /* HttpBindingGenerator.kt:592 */
  695   1007   
    }
        1008  +
    /* HttpBindingGenerator.kt:592 */
  696   1009   
    if let ::std::option::Option::Some(inner_37) = &input.range_integer_list_header {
        1010  +
        /* HttpBindingGenerator.kt:646 */
  697   1011   
        for inner_38 in inner_37 {
        1012  +
            /* HttpBindingGenerator.kt:690 */
  698   1013   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_38.0);
        1014  +
            /* HttpBindingGenerator.kt:704 */
  699   1015   
            let formatted_39 = encoder.encode();
        1016  +
            /* HttpBindingGenerator.kt:705 */
  700   1017   
            if !formatted_39.is_empty() {
        1018  +
                /* HttpBindingGenerator.kt:706 */
  701   1019   
                let header_value = formatted_39;
  702   1020   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  703   1021   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  704   1022   
                        "range_integer_list_header",
  705   1023   
                        format!(
  706   1024   
                            "`{}` cannot be used as a header value: {}",
  707   1025   
                            &header_value, err
  708   1026   
                        ),
  709   1027   
                    )
  710   1028   
                })?;
  711   1029   
                builder = builder.header("X-Range-Integer-List", header_value);
        1030  +
                /* HttpBindingGenerator.kt:705 */
  712   1031   
            }
        1032  +
            /* HttpBindingGenerator.kt:646 */
  713   1033   
        }
        1034  +
        /* HttpBindingGenerator.kt:592 */
  714   1035   
    }
        1036  +
    /* HttpBindingGenerator.kt:592 */
  715   1037   
    if let ::std::option::Option::Some(inner_40) = &input.range_long_list_header {
        1038  +
        /* HttpBindingGenerator.kt:646 */
  716   1039   
        for inner_41 in inner_40 {
        1040  +
            /* HttpBindingGenerator.kt:690 */
  717   1041   
            let mut encoder = ::aws_smithy_types::primitive::Encoder::from(inner_41.0);
        1042  +
            /* HttpBindingGenerator.kt:704 */
  718   1043   
            let formatted_42 = encoder.encode();
        1044  +
            /* HttpBindingGenerator.kt:705 */
  719   1045   
            if !formatted_42.is_empty() {
        1046  +
                /* HttpBindingGenerator.kt:706 */
  720   1047   
                let header_value = formatted_42;
  721   1048   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  722   1049   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  723   1050   
                        "range_long_list_header",
  724   1051   
                        format!(
  725   1052   
                            "`{}` cannot be used as a header value: {}",
  726   1053   
                            &header_value, err
  727   1054   
                        ),
  728   1055   
                    )
  729   1056   
                })?;
  730   1057   
                builder = builder.header("X-Range-Long-List", header_value);
        1058  +
                /* HttpBindingGenerator.kt:705 */
  731   1059   
            }
        1060  +
            /* HttpBindingGenerator.kt:646 */
  732   1061   
        }
        1062  +
        /* HttpBindingGenerator.kt:592 */
  733   1063   
    }
        1064  +
    /* HttpBindingGenerator.kt:741 */
  734   1065   
    {
        1066  +
        /* HttpBindingGenerator.kt:747 */
  735   1067   
        for (k, v) in &input.length_string_header_map {
  736   1068   
            use std::str::FromStr;
  737   1069   
            let header_name = http::header::HeaderName::from_str(&format!(
  738   1070   
                "{}{}",
  739   1071   
                "X-Length-String-Prefix-Headers-", &k
  740   1072   
            ))
  741   1073   
            .map_err(|err| {
  742   1074   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  743   1075   
                    "length_string_header_map",
  744   1076   
                    format!("`{k}` cannot be used as a header name: {err}"),
  745   1077   
                )
  746   1078   
            })?;
  747   1079   
            let header_value = v.as_str();
  748   1080   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  749   1081   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  750   1082   
                    "length_string_header_map",
  751   1083   
                    format!("`{}` cannot be used as a header value: {}", v, err),
  752   1084   
                )
  753   1085   
            })?;
  754   1086   
            builder = builder.header(header_name, header_value);
  755   1087   
        }
        1088  +
        /* HttpBindingGenerator.kt:741 */
  756   1089   
    }
        1090  +
    /* HttpBindingGenerator.kt:555 */
  757   1091   
    Ok(builder)
        1092  +
    /* HttpBindingGenerator.kt:542 */
  758   1093   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_constrained_http_bound_shapes_operation_input.rs

@@ -1,1 +442,582 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* HttpBindingGenerator.kt:153 */
    2      3   
pub(crate) fn de_length_list_pattern_string_header_header(header_map: &::aws_smithy_runtime_api::http::Headers) -> ::std::result::Result<::std::option::Option<crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained>, ::aws_smithy_http::header::ParseError>{
           4  +
    /* HttpBindingGenerator.kt:160 */
    3      5   
    let headers = header_map.get_all("X-Length-List-Pattern-String");
           6  +
    /* HttpBindingGenerator.kt:409 */
    4      7   
    let var_1: Vec<::std::string::String> = ::aws_smithy_http::header::read_many_from_str(headers)?;
           8  +
    /* HttpBindingGenerator.kt:456 */
    5      9   
    Ok(if !var_1.is_empty() {
    6     10   
        Some(crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained(var_1))
    7     11   
    } else {
    8     12   
        None
    9     13   
    })
          14  +
    /* HttpBindingGenerator.kt:153 */
   10     15   
}
   11     16   
          17  +
/* HttpBindingGenerator.kt:153 */
   12     18   
pub(crate) fn de_length_set_pattern_string_header_header(header_map: &::aws_smithy_runtime_api::http::Headers) -> ::std::result::Result<::std::option::Option<crate::unconstrained::length_set_of_pattern_string_unconstrained::LengthSetOfPatternStringUnconstrained>, ::aws_smithy_http::header::ParseError>{
          19  +
    /* HttpBindingGenerator.kt:160 */
   13     20   
    let headers = header_map.get_all("X-Length-Set-Pattern-String");
          21  +
    /* HttpBindingGenerator.kt:409 */
   14     22   
    let var_2: Vec<::std::string::String> = ::aws_smithy_http::header::read_many_from_str(headers)?;
          23  +
    /* HttpBindingGenerator.kt:456 */
   15     24   
    Ok(if !var_2.is_empty() {
   16     25   
        Some(crate::unconstrained::length_set_of_pattern_string_unconstrained::LengthSetOfPatternStringUnconstrained(var_2))
   17     26   
    } else {
   18     27   
        None
   19     28   
    })
          29  +
    /* HttpBindingGenerator.kt:153 */
   20     30   
}
   21     31   
          32  +
/* HttpBindingGenerator.kt:153 */
   22     33   
pub(crate) fn de_length_string_header_header(
   23     34   
    header_map: &::aws_smithy_runtime_api::http::Headers,
   24     35   
) -> ::std::result::Result<
   25     36   
    ::std::option::Option<::std::string::String>,
   26     37   
    ::aws_smithy_http::header::ParseError,
   27     38   
> {
          39  +
    /* HttpBindingGenerator.kt:160 */
   28     40   
    let headers = header_map.get_all("X-Length");
          41  +
    /* HttpBindingGenerator.kt:375 */
   29     42   
    ::aws_smithy_http::header::one_or_none(headers)
          43  +
    /* HttpBindingGenerator.kt:153 */
   30     44   
}
   31     45   
          46  +
/* HttpBindingGenerator.kt:184 */
   32     47   
pub(crate) fn de_length_string_header_map_prefix_header(
   33     48   
    header_map: &::aws_smithy_runtime_api::http::Headers,
   34     49   
) -> std::result::Result<
   35     50   
    ::std::option::Option<
   36     51   
        crate::unconstrained::map_of_length_string_unconstrained::MapOfLengthStringUnconstrained,
   37     52   
    >,
   38     53   
    ::aws_smithy_http::header::ParseError,
   39     54   
> {
          55  +
    /* HttpBindingGenerator.kt:190 */
   40     56   
    let headers = ::aws_smithy_http::header::headers_for_prefix(
   41     57   
        header_map.iter().map(|(k, _)| k),
   42     58   
        "X-Length-String-Prefix-Headers-",
   43     59   
    );
   44     60   
    let out: std::result::Result<_, _> = headers.map(|(key, header_name)| {
   45     61   
                            let values = header_map.get_all(header_name);
   46     62   
                            crate::protocol_serde::shape_constrained_http_bound_shapes_operation_input::de_length_string_header_map_inner(values).map(|v| (key.to_string(), v.expect(
   47     63   
                                "we have checked there is at least one value for this header name; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues"
   48     64   
                            )))
   49     65   
                        }).collect();
          66  +
    /* ServerRequestBindingGenerator.kt:79 */
   50     67   
    let out = out.map(
   51     68   
        crate::unconstrained::map_of_length_string_unconstrained::MapOfLengthStringUnconstrained,
   52     69   
    );
          70  +
    /* HttpBindingGenerator.kt:211 */
   53     71   
    out.map(Some)
          72  +
    /* HttpBindingGenerator.kt:184 */
   54     73   
}
   55     74   
          75  +
/* HttpBindingGenerator.kt:153 */
   56     76   
pub(crate) fn de_length_string_set_header_header(
   57     77   
    header_map: &::aws_smithy_runtime_api::http::Headers,
   58     78   
) -> ::std::result::Result<
   59     79   
    ::std::option::Option<
   60     80   
        crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained,
   61     81   
    >,
   62     82   
    ::aws_smithy_http::header::ParseError,
   63     83   
> {
          84  +
    /* HttpBindingGenerator.kt:160 */
   64     85   
    let headers = header_map.get_all("X-Length-Set");
          86  +
    /* HttpBindingGenerator.kt:409 */
   65     87   
    let var_3: Vec<::std::string::String> = ::aws_smithy_http::header::read_many_from_str(headers)?;
          88  +
    /* HttpBindingGenerator.kt:456 */
   66     89   
    Ok(if !var_3.is_empty() {
   67     90   
        Some(crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained(var_3))
   68     91   
    } else {
   69     92   
        None
   70     93   
    })
          94  +
    /* HttpBindingGenerator.kt:153 */
   71     95   
}
   72     96   
          97  +
/* HttpBindingGenerator.kt:153 */
   73     98   
pub(crate) fn de_list_length_string_header_header(
   74     99   
    header_map: &::aws_smithy_runtime_api::http::Headers,
   75    100   
) -> ::std::result::Result<
   76    101   
    ::std::option::Option<
   77    102   
        crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained,
   78    103   
    >,
   79    104   
    ::aws_smithy_http::header::ParseError,
   80    105   
> {
         106  +
    /* HttpBindingGenerator.kt:160 */
   81    107   
    let headers = header_map.get_all("X-List-Length-String");
         108  +
    /* HttpBindingGenerator.kt:409 */
   82    109   
    let var_4: Vec<::std::string::String> = ::aws_smithy_http::header::read_many_from_str(headers)?;
         110  +
    /* HttpBindingGenerator.kt:456 */
   83    111   
    Ok(if !var_4.is_empty() {
   84    112   
        Some(crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained(var_4))
   85    113   
    } else {
   86    114   
        None
   87    115   
    })
         116  +
    /* HttpBindingGenerator.kt:153 */
   88    117   
}
   89    118   
         119  +
/* HttpBindingGenerator.kt:153 */
   90    120   
pub(crate) fn de_range_byte_header_header(
   91    121   
    header_map: &::aws_smithy_runtime_api::http::Headers,
   92    122   
) -> ::std::result::Result<::std::option::Option<i8>, ::aws_smithy_http::header::ParseError> {
         123  +
    /* HttpBindingGenerator.kt:160 */
   93    124   
    let headers = header_map.get_all("X-Range-Byte");
         125  +
    /* HttpBindingGenerator.kt:404 */
   94    126   
    let var_5 = ::aws_smithy_http::header::read_many_primitive::<i8>(headers)?;
         127  +
    /* HttpBindingGenerator.kt:468 */
   95    128   
    if var_5.len() > 1 {
   96    129   
        Err(::aws_smithy_http::header::ParseError::new(format!(
   97    130   
            "expected one item but found {}",
   98    131   
            var_5.len()
   99    132   
        )))
  100    133   
    } else {
  101    134   
        let mut var_5 = var_5;
  102    135   
        Ok(var_5.pop())
  103    136   
    }
         137  +
    /* HttpBindingGenerator.kt:153 */
  104    138   
}
  105    139   
         140  +
/* HttpBindingGenerator.kt:153 */
  106    141   
pub(crate) fn de_range_byte_list_header_header(
  107    142   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  108    143   
) -> ::std::result::Result<
  109    144   
    ::std::option::Option<
  110    145   
        crate::unconstrained::list_of_range_byte_unconstrained::ListOfRangeByteUnconstrained,
  111    146   
    >,
  112    147   
    ::aws_smithy_http::header::ParseError,
  113    148   
> {
         149  +
    /* HttpBindingGenerator.kt:160 */
  114    150   
    let headers = header_map.get_all("X-Range-Byte-List");
         151  +
    /* HttpBindingGenerator.kt:404 */
  115    152   
    let var_6 = ::aws_smithy_http::header::read_many_primitive::<i8>(headers)?;
         153  +
    /* HttpBindingGenerator.kt:456 */
  116    154   
    Ok(if !var_6.is_empty() {
  117    155   
        Some(
  118    156   
            crate::unconstrained::list_of_range_byte_unconstrained::ListOfRangeByteUnconstrained(
  119    157   
                var_6,
  120    158   
            ),
  121    159   
        )
  122    160   
    } else {
  123    161   
        None
  124    162   
    })
         163  +
    /* HttpBindingGenerator.kt:153 */
  125    164   
}
  126    165   
         166  +
/* HttpBindingGenerator.kt:153 */
  127    167   
pub(crate) fn de_range_byte_set_header_header(
  128    168   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  129    169   
) -> ::std::result::Result<
  130    170   
    ::std::option::Option<
  131    171   
        crate::unconstrained::set_of_range_byte_unconstrained::SetOfRangeByteUnconstrained,
  132    172   
    >,
  133    173   
    ::aws_smithy_http::header::ParseError,
  134    174   
> {
         175  +
    /* HttpBindingGenerator.kt:160 */
  135    176   
    let headers = header_map.get_all("X-Range-Byte-Set");
         177  +
    /* HttpBindingGenerator.kt:404 */
  136    178   
    let var_7 = ::aws_smithy_http::header::read_many_primitive::<i8>(headers)?;
         179  +
    /* HttpBindingGenerator.kt:456 */
  137    180   
    Ok(if !var_7.is_empty() {
  138    181   
        Some(
  139    182   
            crate::unconstrained::set_of_range_byte_unconstrained::SetOfRangeByteUnconstrained(
  140    183   
                var_7,
  141    184   
            ),
  142    185   
        )
  143    186   
    } else {
  144    187   
        None
  145    188   
    })
         189  +
    /* HttpBindingGenerator.kt:153 */
  146    190   
}
  147    191   
         192  +
/* HttpBindingGenerator.kt:153 */
  148    193   
pub(crate) fn de_range_integer_header_header(
  149    194   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  150    195   
) -> ::std::result::Result<::std::option::Option<i32>, ::aws_smithy_http::header::ParseError> {
         196  +
    /* HttpBindingGenerator.kt:160 */
  151    197   
    let headers = header_map.get_all("X-Range-Integer");
         198  +
    /* HttpBindingGenerator.kt:404 */
  152    199   
    let var_8 = ::aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
         200  +
    /* HttpBindingGenerator.kt:468 */
  153    201   
    if var_8.len() > 1 {
  154    202   
        Err(::aws_smithy_http::header::ParseError::new(format!(
  155    203   
            "expected one item but found {}",
  156    204   
            var_8.len()
  157    205   
        )))
  158    206   
    } else {
  159    207   
        let mut var_8 = var_8;
  160    208   
        Ok(var_8.pop())
  161    209   
    }
         210  +
    /* HttpBindingGenerator.kt:153 */
  162    211   
}
  163    212   
         213  +
/* HttpBindingGenerator.kt:153 */
  164    214   
pub(crate) fn de_range_integer_list_header_header(
  165    215   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  166    216   
) -> ::std::result::Result<
  167    217   
    ::std::option::Option<
  168    218   
        crate::unconstrained::list_of_range_integer_unconstrained::ListOfRangeIntegerUnconstrained,
  169    219   
    >,
  170    220   
    ::aws_smithy_http::header::ParseError,
  171    221   
> {
         222  +
    /* HttpBindingGenerator.kt:160 */
  172    223   
    let headers = header_map.get_all("X-Range-Integer-List");
         224  +
    /* HttpBindingGenerator.kt:404 */
  173    225   
    let var_9 = ::aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
         226  +
    /* HttpBindingGenerator.kt:456 */
  174    227   
    Ok(if !var_9.is_empty() {
  175    228   
        Some(crate::unconstrained::list_of_range_integer_unconstrained::ListOfRangeIntegerUnconstrained(var_9))
  176    229   
    } else {
  177    230   
        None
  178    231   
    })
         232  +
    /* HttpBindingGenerator.kt:153 */
  179    233   
}
  180    234   
         235  +
/* HttpBindingGenerator.kt:153 */
  181    236   
pub(crate) fn de_range_integer_set_header_header(
  182    237   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  183    238   
) -> ::std::result::Result<
  184    239   
    ::std::option::Option<
  185    240   
        crate::unconstrained::set_of_range_integer_unconstrained::SetOfRangeIntegerUnconstrained,
  186    241   
    >,
  187    242   
    ::aws_smithy_http::header::ParseError,
  188    243   
> {
         244  +
    /* HttpBindingGenerator.kt:160 */
  189    245   
    let headers = header_map.get_all("X-Range-Integer-Set");
         246  +
    /* HttpBindingGenerator.kt:404 */
  190    247   
    let var_10 = ::aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
         248  +
    /* HttpBindingGenerator.kt:456 */
  191    249   
    Ok(if !var_10.is_empty() {
  192    250   
        Some(crate::unconstrained::set_of_range_integer_unconstrained::SetOfRangeIntegerUnconstrained(var_10))
  193    251   
    } else {
  194    252   
        None
  195    253   
    })
         254  +
    /* HttpBindingGenerator.kt:153 */
  196    255   
}
  197    256   
         257  +
/* HttpBindingGenerator.kt:153 */
  198    258   
pub(crate) fn de_range_long_header_header(
  199    259   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  200    260   
) -> ::std::result::Result<::std::option::Option<i64>, ::aws_smithy_http::header::ParseError> {
         261  +
    /* HttpBindingGenerator.kt:160 */
  201    262   
    let headers = header_map.get_all("X-Range-Long");
         263  +
    /* HttpBindingGenerator.kt:404 */
  202    264   
    let var_11 = ::aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
         265  +
    /* HttpBindingGenerator.kt:468 */
  203    266   
    if var_11.len() > 1 {
  204    267   
        Err(::aws_smithy_http::header::ParseError::new(format!(
  205    268   
            "expected one item but found {}",
  206    269   
            var_11.len()
  207    270   
        )))
  208    271   
    } else {
  209    272   
        let mut var_11 = var_11;
  210    273   
        Ok(var_11.pop())
  211    274   
    }
         275  +
    /* HttpBindingGenerator.kt:153 */
  212    276   
}
  213    277   
         278  +
/* HttpBindingGenerator.kt:153 */
  214    279   
pub(crate) fn de_range_long_list_header_header(
  215    280   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  216    281   
) -> ::std::result::Result<
  217    282   
    ::std::option::Option<
  218    283   
        crate::unconstrained::list_of_range_long_unconstrained::ListOfRangeLongUnconstrained,
  219    284   
    >,
  220    285   
    ::aws_smithy_http::header::ParseError,
  221    286   
> {
         287  +
    /* HttpBindingGenerator.kt:160 */
  222    288   
    let headers = header_map.get_all("X-Range-Long-List");
         289  +
    /* HttpBindingGenerator.kt:404 */
  223    290   
    let var_12 = ::aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
         291  +
    /* HttpBindingGenerator.kt:456 */
  224    292   
    Ok(if !var_12.is_empty() {
  225    293   
        Some(
  226    294   
            crate::unconstrained::list_of_range_long_unconstrained::ListOfRangeLongUnconstrained(
  227    295   
                var_12,
  228    296   
            ),
  229    297   
        )
  230    298   
    } else {
  231    299   
        None
  232    300   
    })
         301  +
    /* HttpBindingGenerator.kt:153 */
  233    302   
}
  234    303   
         304  +
/* HttpBindingGenerator.kt:153 */
  235    305   
pub(crate) fn de_range_long_set_header_header(
  236    306   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  237    307   
) -> ::std::result::Result<
  238    308   
    ::std::option::Option<
  239    309   
        crate::unconstrained::set_of_range_long_unconstrained::SetOfRangeLongUnconstrained,
  240    310   
    >,
  241    311   
    ::aws_smithy_http::header::ParseError,
  242    312   
> {
         313  +
    /* HttpBindingGenerator.kt:160 */
  243    314   
    let headers = header_map.get_all("X-Range-Long-Set");
         315  +
    /* HttpBindingGenerator.kt:404 */
  244    316   
    let var_13 = ::aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
         317  +
    /* HttpBindingGenerator.kt:456 */
  245    318   
    Ok(if !var_13.is_empty() {
  246    319   
        Some(
  247    320   
            crate::unconstrained::set_of_range_long_unconstrained::SetOfRangeLongUnconstrained(
  248    321   
                var_13,
  249    322   
            ),
  250    323   
        )
  251    324   
    } else {
  252    325   
        None
  253    326   
    })
         327  +
    /* HttpBindingGenerator.kt:153 */
  254    328   
}
  255    329   
         330  +
/* HttpBindingGenerator.kt:153 */
  256    331   
pub(crate) fn de_range_short_header_header(
  257    332   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  258    333   
) -> ::std::result::Result<::std::option::Option<i16>, ::aws_smithy_http::header::ParseError> {
         334  +
    /* HttpBindingGenerator.kt:160 */
  259    335   
    let headers = header_map.get_all("X-Range-Short");
         336  +
    /* HttpBindingGenerator.kt:404 */
  260    337   
    let var_14 = ::aws_smithy_http::header::read_many_primitive::<i16>(headers)?;
         338  +
    /* HttpBindingGenerator.kt:468 */
  261    339   
    if var_14.len() > 1 {
  262    340   
        Err(::aws_smithy_http::header::ParseError::new(format!(
  263    341   
            "expected one item but found {}",
  264    342   
            var_14.len()
  265    343   
        )))
  266    344   
    } else {
  267    345   
        let mut var_14 = var_14;
  268    346   
        Ok(var_14.pop())
  269    347   
    }
         348  +
    /* HttpBindingGenerator.kt:153 */
  270    349   
}
  271    350   
         351  +
/* HttpBindingGenerator.kt:153 */
  272    352   
pub(crate) fn de_range_short_list_header_header(
  273    353   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  274    354   
) -> ::std::result::Result<
  275    355   
    ::std::option::Option<
  276    356   
        crate::unconstrained::list_of_range_short_unconstrained::ListOfRangeShortUnconstrained,
  277    357   
    >,
  278    358   
    ::aws_smithy_http::header::ParseError,
  279    359   
> {
         360  +
    /* HttpBindingGenerator.kt:160 */
  280    361   
    let headers = header_map.get_all("X-Range-Short-List");
         362  +
    /* HttpBindingGenerator.kt:404 */
  281    363   
    let var_15 = ::aws_smithy_http::header::read_many_primitive::<i16>(headers)?;
         364  +
    /* HttpBindingGenerator.kt:456 */
  282    365   
    Ok(if !var_15.is_empty() {
  283    366   
        Some(
  284    367   
            crate::unconstrained::list_of_range_short_unconstrained::ListOfRangeShortUnconstrained(
  285    368   
                var_15,
  286    369   
            ),
  287    370   
        )
  288    371   
    } else {
  289    372   
        None
  290    373   
    })
         374  +
    /* HttpBindingGenerator.kt:153 */
  291    375   
}
  292    376   
         377  +
/* HttpBindingGenerator.kt:153 */
  293    378   
pub(crate) fn de_range_short_set_header_header(
  294    379   
    header_map: &::aws_smithy_runtime_api::http::Headers,
  295    380   
) -> ::std::result::Result<
  296    381   
    ::std::option::Option<
  297    382   
        crate::unconstrained::set_of_range_short_unconstrained::SetOfRangeShortUnconstrained,
  298    383   
    >,
  299    384   
    ::aws_smithy_http::header::ParseError,
  300    385   
> {
         386  +
    /* HttpBindingGenerator.kt:160 */
  301    387   
    let headers = header_map.get_all("X-Range-Short-Set");
         388  +
    /* HttpBindingGenerator.kt:404 */
  302    389   
    let var_16 = ::aws_smithy_http::header::read_many_primitive::<i16>(headers)?;
         390  +
    /* HttpBindingGenerator.kt:456 */
  303    391   
    Ok(if !var_16.is_empty() {
  304    392   
        Some(
  305    393   
            crate::unconstrained::set_of_range_short_unconstrained::SetOfRangeShortUnconstrained(
  306    394   
                var_16,
  307    395   
            ),
  308    396   
        )
  309    397   
    } else {
  310    398   
        None
  311    399   
    })
         400  +
    /* HttpBindingGenerator.kt:153 */
  312    401   
}
  313    402   
         403  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  314    404   
pub fn de_range_integer_label(
  315    405   
    value: &str,
  316    406   
) -> std::result::Result<
  317    407   
    i32,
  318    408   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  319    409   
> {
         410  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  320    411   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         412  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  321    413   
    Ok(value)
         414  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  322    415   
}
  323    416   
         417  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  324    418   
pub fn de_range_short_label(
  325    419   
    value: &str,
  326    420   
) -> std::result::Result<
  327    421   
    i16,
  328    422   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  329    423   
> {
         424  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  330    425   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         426  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  331    427   
    Ok(value)
         428  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  332    429   
}
  333    430   
         431  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  334    432   
pub fn de_range_long_label(
  335    433   
    value: &str,
  336    434   
) -> std::result::Result<
  337    435   
    i64,
  338    436   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  339    437   
> {
         438  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  340    439   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         440  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  341    441   
    Ok(value)
         442  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  342    443   
}
  343    444   
         445  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  344    446   
pub fn de_range_byte_label(
  345    447   
    value: &str,
  346    448   
) -> std::result::Result<
  347    449   
    i8,
  348    450   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  349    451   
> {
         452  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  350    453   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         454  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  351    455   
    Ok(value)
         456  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  352    457   
}
  353    458   
         459  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  354    460   
pub fn de_length_string_label(
  355    461   
    value: &str,
  356    462   
) -> std::result::Result<
  357    463   
    ::std::string::String,
  358    464   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  359    465   
> {
         466  +
    /* ServerHttpBoundProtocolGenerator.kt:1302 */
  360    467   
    let value = ::percent_encoding::percent_decode_str(value)
  361    468   
        .decode_utf8()?
  362    469   
        .into_owned();
         470  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  363    471   
    Ok(value)
         472  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  364    473   
}
  365    474   
         475  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  366    476   
pub fn de_enum_string_label(
  367    477   
    value: &str,
  368    478   
) -> std::result::Result<
  369    479   
    ::std::string::String,
  370    480   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  371    481   
> {
         482  +
    /* ServerHttpBoundProtocolGenerator.kt:1302 */
  372    483   
    let value = ::percent_encoding::percent_decode_str(value)
  373    484   
        .decode_utf8()?
  374    485   
        .into_owned();
         486  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  375    487   
    Ok(value)
         488  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  376    489   
}
  377    490   
         491  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  378    492   
pub fn de_enum_string_query(
  379    493   
    value: &str,
  380    494   
) -> std::result::Result<
  381    495   
    ::std::option::Option<::std::string::String>,
  382    496   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  383    497   
> {
         498  +
    /* ServerHttpBoundProtocolGenerator.kt:1309 */
  384    499   
    let value = value.to_owned();
         500  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  385    501   
    Ok(Some(value))
         502  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  386    503   
}
  387    504   
         505  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  388    506   
pub fn de_length_string_query(
  389    507   
    value: &str,
  390    508   
) -> std::result::Result<
  391    509   
    ::std::option::Option<::std::string::String>,
  392    510   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  393    511   
> {
         512  +
    /* ServerHttpBoundProtocolGenerator.kt:1309 */
  394    513   
    let value = value.to_owned();
         514  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  395    515   
    Ok(Some(value))
         516  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  396    517   
}
  397    518   
         519  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  398    520   
pub fn de_range_byte_query(
  399    521   
    value: &str,
  400    522   
) -> std::result::Result<
  401    523   
    i8,
  402    524   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  403    525   
> {
         526  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  404    527   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         528  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  405    529   
    Ok(value)
         530  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  406    531   
}
  407    532   
         533  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  408    534   
pub fn de_range_integer_query(
  409    535   
    value: &str,
  410    536   
) -> std::result::Result<
  411    537   
    i32,
  412    538   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  413    539   
> {
         540  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  414    541   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         542  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  415    543   
    Ok(value)
         544  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  416    545   
}
  417    546   
         547  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  418    548   
pub fn de_range_long_query(
  419    549   
    value: &str,
  420    550   
) -> std::result::Result<
  421    551   
    i64,
  422    552   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  423    553   
> {
         554  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  424    555   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         556  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  425    557   
    Ok(value)
         558  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  426    559   
}
  427    560   
         561  +
/* ServerHttpBoundProtocolGenerator.kt:1292 */
  428    562   
pub fn de_range_short_query(
  429    563   
    value: &str,
  430    564   
) -> std::result::Result<
  431    565   
    i16,
  432    566   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
  433    567   
> {
         568  +
    /* ServerHttpBoundProtocolGenerator.kt:1347 */
  434    569   
    let value = <_ as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(value)?;
         570  +
    /* ServerHttpBoundProtocolGenerator.kt:1357 */
  435    571   
    Ok(value)
         572  +
    /* ServerHttpBoundProtocolGenerator.kt:1292 */
  436    573   
}
  437    574   
         575  +
/* HttpBindingGenerator.kt:173 */
  438    576   
pub fn de_length_string_header_map_inner<'a>(
  439    577   
    headers: impl ::std::iter::Iterator<Item = &'a str>,
  440    578   
) -> std::result::Result<Option<::std::string::String>, ::aws_smithy_http::header::ParseError> {
         579  +
    /* HttpBindingGenerator.kt:375 */
  441    580   
    ::aws_smithy_http::header::one_or_none(headers)
         581  +
    /* HttpBindingGenerator.kt:173 */
  442    582   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_constrained_http_bound_shapes_operation_output.rs

@@ -1,1 +213,365 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonSerializerGenerator.kt:213 */
    2      3   
pub fn ser_constrained_http_bound_shapes_operation_output_output_output(
    3      4   
    value: &crate::output::ConstrainedHttpBoundShapesOperationOutput,
    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_constrained_http_bound_shapes_operation_output::ser_constrained_http_bound_shapes_operation_output_output(&mut object, value)?;
          11  +
    /* JsonSerializerGenerator.kt:227 */
    8     12   
    object.finish();
    9     13   
    Ok(out)
          14  +
    /* JsonSerializerGenerator.kt:213 */
   10     15   
}
   11     16   
          17  +
/* JsonSerializerGenerator.kt:358 */
   12     18   
pub fn ser_constrained_http_bound_shapes_operation_output_output(
   13     19   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
   14     20   
    input: &crate::output::ConstrainedHttpBoundShapesOperationOutput,
   15     21   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
          22  +
    /* SerializerUtil.kt:42 */
   16     23   
    {
          24  +
        /* JsonSerializerGenerator.kt:423 */
   17     25   
        object
   18     26   
            .key("enumStringLabel")
   19     27   
            .string(input.enum_string_label.as_str());
          28  +
        /* SerializerUtil.kt:42 */
   20     29   
    }
          30  +
    /* JsonSerializerGenerator.kt:382 */
   21     31   
    if let Some(var_1) = &input.enum_string_list_query {
          32  +
        /* JsonSerializerGenerator.kt:484 */
   22     33   
        let mut array_2 = object.key("enumStringListQuery").start_array();
          34  +
        /* JsonSerializerGenerator.kt:524 */
   23     35   
        for item_3 in var_1 {
          36  +
            /* SerializerUtil.kt:42 */
   24     37   
            {
          38  +
                /* JsonSerializerGenerator.kt:423 */
   25     39   
                array_2.value().string(item_3.as_str());
          40  +
                /* SerializerUtil.kt:42 */
   26     41   
            }
          42  +
            /* JsonSerializerGenerator.kt:524 */
   27     43   
        }
          44  +
        /* JsonSerializerGenerator.kt:486 */
   28     45   
        array_2.finish();
          46  +
        /* JsonSerializerGenerator.kt:382 */
   29     47   
    }
          48  +
    /* JsonSerializerGenerator.kt:382 */
   30     49   
    if let Some(var_4) = &input.enum_string_query {
          50  +
        /* JsonSerializerGenerator.kt:423 */
   31     51   
        object.key("enumStringQuery").string(var_4.as_str());
          52  +
        /* JsonSerializerGenerator.kt:382 */
   32     53   
    }
          54  +
    /* JsonSerializerGenerator.kt:382 */
   33     55   
    if let Some(var_5) = &input.length_list_pattern_string_query {
          56  +
        /* JsonSerializerGenerator.kt:484 */
   34     57   
        let mut array_6 = object.key("lengthListPatternStringQuery").start_array();
          58  +
        /* JsonSerializerGenerator.kt:524 */
   35     59   
        for item_7 in &var_5.0 {
          60  +
            /* SerializerUtil.kt:42 */
   36     61   
            {
          62  +
                /* JsonSerializerGenerator.kt:423 */
   37     63   
                array_6.value().string(item_7.as_str());
          64  +
                /* SerializerUtil.kt:42 */
   38     65   
            }
          66  +
            /* JsonSerializerGenerator.kt:524 */
   39     67   
        }
          68  +
        /* JsonSerializerGenerator.kt:486 */
   40     69   
        array_6.finish();
          70  +
        /* JsonSerializerGenerator.kt:382 */
   41     71   
    }
          72  +
    /* SerializerUtil.kt:42 */
   42     73   
    {
          74  +
        /* JsonSerializerGenerator.kt:423 */
   43     75   
        object
   44     76   
            .key("lengthStringLabel")
   45     77   
            .string(input.length_string_label.as_str());
          78  +
        /* SerializerUtil.kt:42 */
   46     79   
    }
          80  +
    /* JsonSerializerGenerator.kt:382 */
   47     81   
    if let Some(var_8) = &input.length_string_list_query {
          82  +
        /* JsonSerializerGenerator.kt:484 */
   48     83   
        let mut array_9 = object.key("lengthStringListQuery").start_array();
          84  +
        /* JsonSerializerGenerator.kt:524 */
   49     85   
        for item_10 in var_8 {
          86  +
            /* SerializerUtil.kt:42 */
   50     87   
            {
          88  +
                /* JsonSerializerGenerator.kt:423 */
   51     89   
                array_9.value().string(item_10.as_str());
          90  +
                /* SerializerUtil.kt:42 */
   52     91   
            }
          92  +
            /* JsonSerializerGenerator.kt:524 */
   53     93   
        }
          94  +
        /* JsonSerializerGenerator.kt:486 */
   54     95   
        array_9.finish();
          96  +
        /* JsonSerializerGenerator.kt:382 */
   55     97   
    }
          98  +
    /* JsonSerializerGenerator.kt:382 */
   56     99   
    if let Some(var_11) = &input.length_string_query {
         100  +
        /* JsonSerializerGenerator.kt:423 */
   57    101   
        object.key("lengthStringQuery").string(var_11.as_str());
         102  +
        /* JsonSerializerGenerator.kt:382 */
   58    103   
    }
         104  +
    /* JsonSerializerGenerator.kt:382 */
   59    105   
    if let Some(var_12) = &input.length_string_set_query {
         106  +
        /* JsonSerializerGenerator.kt:484 */
   60    107   
        let mut array_13 = object.key("lengthStringSetQuery").start_array();
         108  +
        /* JsonSerializerGenerator.kt:524 */
   61    109   
        for item_14 in &var_12.0 {
         110  +
            /* SerializerUtil.kt:42 */
   62    111   
            {
         112  +
                /* JsonSerializerGenerator.kt:423 */
   63    113   
                array_13.value().string(item_14.as_str());
         114  +
                /* SerializerUtil.kt:42 */
   64    115   
            }
         116  +
            /* JsonSerializerGenerator.kt:524 */
   65    117   
        }
         118  +
        /* JsonSerializerGenerator.kt:486 */
   66    119   
        array_13.finish();
         120  +
        /* JsonSerializerGenerator.kt:382 */
   67    121   
    }
         122  +
    /* SerializerUtil.kt:42 */
   68    123   
    {
         124  +
        /* JsonSerializerGenerator.kt:432 */
   69    125   
        object.key("rangeByteLabel").number(
   70    126   
            #[allow(clippy::useless_conversion)]
   71    127   
            ::aws_smithy_types::Number::NegInt((input.range_byte_label.0).into()),
   72    128   
        );
         129  +
        /* SerializerUtil.kt:42 */
   73    130   
    }
         131  +
    /* JsonSerializerGenerator.kt:382 */
   74    132   
    if let Some(var_15) = &input.range_byte_list_query {
         133  +
        /* JsonSerializerGenerator.kt:484 */
   75    134   
        let mut array_16 = object.key("rangeByteListQuery").start_array();
         135  +
        /* JsonSerializerGenerator.kt:524 */
   76    136   
        for item_17 in var_15 {
         137  +
            /* SerializerUtil.kt:42 */
   77    138   
            {
         139  +
                /* JsonSerializerGenerator.kt:432 */
   78    140   
                array_16.value().number(
   79    141   
                    #[allow(clippy::useless_conversion)]
   80    142   
                    ::aws_smithy_types::Number::NegInt((item_17.0).into()),
   81    143   
                );
         144  +
                /* SerializerUtil.kt:42 */
   82    145   
            }
         146  +
            /* JsonSerializerGenerator.kt:524 */
   83    147   
        }
         148  +
        /* JsonSerializerGenerator.kt:486 */
   84    149   
        array_16.finish();
         150  +
        /* JsonSerializerGenerator.kt:382 */
   85    151   
    }
         152  +
    /* SerializerUtil.kt:46 */
   86    153   
    {
         154  +
        /* JsonSerializerGenerator.kt:432 */
   87    155   
        object.key("rangeByteQuery").number(
   88    156   
            #[allow(clippy::useless_conversion)]
   89    157   
            ::aws_smithy_types::Number::NegInt((input.range_byte_query.0).into()),
   90    158   
        );
         159  +
        /* SerializerUtil.kt:46 */
   91    160   
    }
         161  +
    /* JsonSerializerGenerator.kt:382 */
   92    162   
    if let Some(var_18) = &input.range_byte_set_query {
         163  +
        /* JsonSerializerGenerator.kt:484 */
   93    164   
        let mut array_19 = object.key("rangeByteSetQuery").start_array();
         165  +
        /* JsonSerializerGenerator.kt:524 */
   94    166   
        for item_20 in &var_18.0 {
         167  +
            /* SerializerUtil.kt:42 */
   95    168   
            {
         169  +
                /* JsonSerializerGenerator.kt:432 */
   96    170   
                array_19.value().number(
   97    171   
                    #[allow(clippy::useless_conversion)]
   98    172   
                    ::aws_smithy_types::Number::NegInt((item_20.0).into()),
   99    173   
                );
         174  +
                /* SerializerUtil.kt:42 */
  100    175   
            }
         176  +
            /* JsonSerializerGenerator.kt:524 */
  101    177   
        }
         178  +
        /* JsonSerializerGenerator.kt:486 */
  102    179   
        array_19.finish();
         180  +
        /* JsonSerializerGenerator.kt:382 */
  103    181   
    }
         182  +
    /* SerializerUtil.kt:42 */
  104    183   
    {
         184  +
        /* JsonSerializerGenerator.kt:432 */
  105    185   
        object.key("rangeIntegerLabel").number(
  106    186   
            #[allow(clippy::useless_conversion)]
  107    187   
            ::aws_smithy_types::Number::NegInt((input.range_integer_label.0).into()),
  108    188   
        );
         189  +
        /* SerializerUtil.kt:42 */
  109    190   
    }
         191  +
    /* JsonSerializerGenerator.kt:382 */
  110    192   
    if let Some(var_21) = &input.range_integer_list_query {
         193  +
        /* JsonSerializerGenerator.kt:484 */
  111    194   
        let mut array_22 = object.key("rangeIntegerListQuery").start_array();
         195  +
        /* JsonSerializerGenerator.kt:524 */
  112    196   
        for item_23 in var_21 {
         197  +
            /* SerializerUtil.kt:42 */
  113    198   
            {
         199  +
                /* JsonSerializerGenerator.kt:432 */
  114    200   
                array_22.value().number(
  115    201   
                    #[allow(clippy::useless_conversion)]
  116    202   
                    ::aws_smithy_types::Number::NegInt((item_23.0).into()),
  117    203   
                );
         204  +
                /* SerializerUtil.kt:42 */
  118    205   
            }
         206  +
            /* JsonSerializerGenerator.kt:524 */
  119    207   
        }
         208  +
        /* JsonSerializerGenerator.kt:486 */
  120    209   
        array_22.finish();
         210  +
        /* JsonSerializerGenerator.kt:382 */
  121    211   
    }
         212  +
    /* SerializerUtil.kt:46 */
  122    213   
    {
         214  +
        /* JsonSerializerGenerator.kt:432 */
  123    215   
        object.key("rangeIntegerQuery").number(
  124    216   
            #[allow(clippy::useless_conversion)]
  125    217   
            ::aws_smithy_types::Number::NegInt((input.range_integer_query.0).into()),
  126    218   
        );
         219  +
        /* SerializerUtil.kt:46 */
  127    220   
    }
         221  +
    /* JsonSerializerGenerator.kt:382 */
  128    222   
    if let Some(var_24) = &input.range_integer_set_query {
         223  +
        /* JsonSerializerGenerator.kt:484 */
  129    224   
        let mut array_25 = object.key("rangeIntegerSetQuery").start_array();
         225  +
        /* JsonSerializerGenerator.kt:524 */
  130    226   
        for item_26 in &var_24.0 {
         227  +
            /* SerializerUtil.kt:42 */
  131    228   
            {
         229  +
                /* JsonSerializerGenerator.kt:432 */
  132    230   
                array_25.value().number(
  133    231   
                    #[allow(clippy::useless_conversion)]
  134    232   
                    ::aws_smithy_types::Number::NegInt((item_26.0).into()),
  135    233   
                );
         234  +
                /* SerializerUtil.kt:42 */
  136    235   
            }
         236  +
            /* JsonSerializerGenerator.kt:524 */
  137    237   
        }
         238  +
        /* JsonSerializerGenerator.kt:486 */
  138    239   
        array_25.finish();
         240  +
        /* JsonSerializerGenerator.kt:382 */
  139    241   
    }
         242  +
    /* SerializerUtil.kt:42 */
  140    243   
    {
         244  +
        /* JsonSerializerGenerator.kt:432 */
  141    245   
        object.key("rangeLongLabel").number(
  142    246   
            #[allow(clippy::useless_conversion)]
  143    247   
            ::aws_smithy_types::Number::NegInt((input.range_long_label.0).into()),
  144    248   
        );
         249  +
        /* SerializerUtil.kt:42 */
  145    250   
    }
         251  +
    /* JsonSerializerGenerator.kt:382 */
  146    252   
    if let Some(var_27) = &input.range_long_list_query {
         253  +
        /* JsonSerializerGenerator.kt:484 */
  147    254   
        let mut array_28 = object.key("rangeLongListQuery").start_array();
         255  +
        /* JsonSerializerGenerator.kt:524 */
  148    256   
        for item_29 in var_27 {
         257  +
            /* SerializerUtil.kt:42 */
  149    258   
            {
         259  +
                /* JsonSerializerGenerator.kt:432 */
  150    260   
                array_28.value().number(
  151    261   
                    #[allow(clippy::useless_conversion)]
  152    262   
                    ::aws_smithy_types::Number::NegInt((item_29.0).into()),
  153    263   
                );
         264  +
                /* SerializerUtil.kt:42 */
  154    265   
            }
         266  +
            /* JsonSerializerGenerator.kt:524 */
  155    267   
        }
         268  +
        /* JsonSerializerGenerator.kt:486 */
  156    269   
        array_28.finish();
         270  +
        /* JsonSerializerGenerator.kt:382 */
  157    271   
    }
         272  +
    /* SerializerUtil.kt:46 */
  158    273   
    {
         274  +
        /* JsonSerializerGenerator.kt:432 */
  159    275   
        object.key("rangeLongQuery").number(
  160    276   
            #[allow(clippy::useless_conversion)]
  161    277   
            ::aws_smithy_types::Number::NegInt((input.range_long_query.0).into()),
  162    278   
        );
         279  +
        /* SerializerUtil.kt:46 */
  163    280   
    }
         281  +
    /* JsonSerializerGenerator.kt:382 */
  164    282   
    if let Some(var_30) = &input.range_long_set_query {
         283  +
        /* JsonSerializerGenerator.kt:484 */
  165    284   
        let mut array_31 = object.key("rangeLongSetQuery").start_array();
         285  +
        /* JsonSerializerGenerator.kt:524 */
  166    286   
        for item_32 in &var_30.0 {
         287  +
            /* SerializerUtil.kt:42 */
  167    288   
            {
         289  +
                /* JsonSerializerGenerator.kt:432 */
  168    290   
                array_31.value().number(
  169    291   
                    #[allow(clippy::useless_conversion)]
  170    292   
                    ::aws_smithy_types::Number::NegInt((item_32.0).into()),
  171    293   
                );
         294  +
                /* SerializerUtil.kt:42 */
  172    295   
            }
         296  +
            /* JsonSerializerGenerator.kt:524 */
  173    297   
        }
         298  +
        /* JsonSerializerGenerator.kt:486 */
  174    299   
        array_31.finish();
         300  +
        /* JsonSerializerGenerator.kt:382 */
  175    301   
    }
         302  +
    /* SerializerUtil.kt:42 */
  176    303   
    {
         304  +
        /* JsonSerializerGenerator.kt:432 */
  177    305   
        object.key("rangeShortLabel").number(
  178    306   
            #[allow(clippy::useless_conversion)]
  179    307   
            ::aws_smithy_types::Number::NegInt((input.range_short_label.0).into()),
  180    308   
        );
         309  +
        /* SerializerUtil.kt:42 */
  181    310   
    }
         311  +
    /* JsonSerializerGenerator.kt:382 */
  182    312   
    if let Some(var_33) = &input.range_short_list_query {
         313  +
        /* JsonSerializerGenerator.kt:484 */
  183    314   
        let mut array_34 = object.key("rangeShortListQuery").start_array();
         315  +
        /* JsonSerializerGenerator.kt:524 */
  184    316   
        for item_35 in var_33 {
         317  +
            /* SerializerUtil.kt:42 */
  185    318   
            {
         319  +
                /* JsonSerializerGenerator.kt:432 */
  186    320   
                array_34.value().number(
  187    321   
                    #[allow(clippy::useless_conversion)]
  188    322   
                    ::aws_smithy_types::Number::NegInt((item_35.0).into()),
  189    323   
                );
         324  +
                /* SerializerUtil.kt:42 */
  190    325   
            }
         326  +
            /* JsonSerializerGenerator.kt:524 */
  191    327   
        }
         328  +
        /* JsonSerializerGenerator.kt:486 */
  192    329   
        array_34.finish();
         330  +
        /* JsonSerializerGenerator.kt:382 */
  193    331   
    }
         332  +
    /* SerializerUtil.kt:46 */
  194    333   
    {
         334  +
        /* JsonSerializerGenerator.kt:432 */
  195    335   
        object.key("rangeShortQuery").number(
  196    336   
            #[allow(clippy::useless_conversion)]
  197    337   
            ::aws_smithy_types::Number::NegInt((input.range_short_query.0).into()),
  198    338   
        );
         339  +
        /* SerializerUtil.kt:46 */
  199    340   
    }
         341  +
    /* JsonSerializerGenerator.kt:382 */
  200    342   
    if let Some(var_36) = &input.range_short_set_query {
         343  +
        /* JsonSerializerGenerator.kt:484 */
  201    344   
        let mut array_37 = object.key("rangeShortSetQuery").start_array();
         345  +
        /* JsonSerializerGenerator.kt:524 */
  202    346   
        for item_38 in &var_36.0 {
         347  +
            /* SerializerUtil.kt:42 */
  203    348   
            {
         349  +
                /* JsonSerializerGenerator.kt:432 */
  204    350   
                array_37.value().number(
  205    351   
                    #[allow(clippy::useless_conversion)]
  206    352   
                    ::aws_smithy_types::Number::NegInt((item_38.0).into()),
  207    353   
                );
         354  +
                /* SerializerUtil.kt:42 */
  208    355   
            }
         356  +
            /* JsonSerializerGenerator.kt:524 */
  209    357   
        }
         358  +
        /* JsonSerializerGenerator.kt:486 */
  210    359   
        array_37.finish();
         360  +
        /* JsonSerializerGenerator.kt:382 */
  211    361   
    }
         362  +
    /* JsonSerializerGenerator.kt:372 */
  212    363   
    Ok(())
         364  +
    /* JsonSerializerGenerator.kt:358 */
  213    365   
}