Server Test

Server Test

rev. ee474c7509d7728618c23068f3741e8e5b339ef9 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types-http0x/rust-server-codegen/src/protocol_serde.rs

@@ -0,1 +0,206 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) mod shape_constrained_http_bound_shapes_operation;
           3  +
           4  +
pub(crate) mod shape_constrained_http_payload_bound_shape_operation;
           5  +
           6  +
pub(crate) mod shape_constrained_recursive_shapes_operation;
           7  +
           8  +
pub(crate) mod shape_constrained_shapes_only_in_output_operation;
           9  +
          10  +
pub(crate) mod shape_constrained_shapes_operation;
          11  +
          12  +
pub(crate) mod shape_event_streams_operation;
          13  +
          14  +
pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation;
          15  +
          16  +
pub(crate) mod shape_non_streaming_blob_operation;
          17  +
          18  +
pub(crate) mod shape_query_params_targeting_length_map_operation;
          19  +
          20  +
pub(crate) mod shape_query_params_targeting_map_of_enum_string_operation;
          21  +
          22  +
pub(crate) mod shape_query_params_targeting_map_of_length_list_of_pattern_string_operation;
          23  +
          24  +
pub(crate) mod shape_query_params_targeting_map_of_length_pattern_string_operation;
          25  +
          26  +
pub(crate) mod shape_query_params_targeting_map_of_length_string_operation;
          27  +
          28  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_enum_string_operation;
          29  +
          30  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_pattern_string_operation;
          31  +
          32  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_string_operation;
          33  +
          34  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_pattern_string_operation;
          35  +
          36  +
pub(crate) mod shape_query_params_targeting_map_of_pattern_string_operation;
          37  +
          38  +
pub(crate) mod shape_query_params_targeting_map_of_set_of_length_string_operation;
          39  +
          40  +
pub(crate) mod shape_streaming_blob_operation;
          41  +
          42  +
pub(crate) mod shape_constrained_http_bound_shapes_operation_input;
          43  +
          44  +
pub(crate) mod shape_constrained_http_bound_shapes_operation_output;
          45  +
          46  +
pub(crate) mod shape_constrained_http_payload_bound_shape_operation_input;
          47  +
          48  +
pub(crate) mod shape_constrained_http_payload_bound_shape_operation_output;
          49  +
          50  +
pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
          51  +
    if data.is_empty() {
          52  +
        b"{}"
          53  +
    } else {
          54  +
        data
          55  +
    }
          56  +
}
          57  +
          58  +
pub(crate) mod shape_constrained_recursive_shapes_operation_output;
          59  +
          60  +
pub(crate) mod shape_constrained_shapes_only_in_output_operation_output;
          61  +
          62  +
pub(crate) mod shape_constrained_shapes_operation_output;
          63  +
          64  +
pub(crate) mod shape_event_stream_error_message;
          65  +
          66  +
pub(crate) mod shape_event_streams_operation_input;
          67  +
          68  +
pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation_input;
          69  +
          70  +
pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation_output;
          71  +
          72  +
pub(crate) mod shape_non_streaming_blob_operation_input;
          73  +
          74  +
pub(crate) mod shape_non_streaming_blob_operation_output;
          75  +
          76  +
pub(crate) mod shape_query_params_targeting_length_map_operation_output;
          77  +
          78  +
pub(crate) mod shape_query_params_targeting_map_of_enum_string_operation_output;
          79  +
          80  +
pub(crate) mod shape_query_params_targeting_map_of_length_list_of_pattern_string_operation_output;
          81  +
          82  +
pub(crate) mod shape_query_params_targeting_map_of_length_pattern_string_operation_output;
          83  +
          84  +
pub(crate) mod shape_query_params_targeting_map_of_length_string_operation_output;
          85  +
          86  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_enum_string_operation_output;
          87  +
          88  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_pattern_string_operation_output;
          89  +
          90  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_string_operation_output;
          91  +
          92  +
pub(crate) mod shape_query_params_targeting_map_of_list_of_pattern_string_operation_output;
          93  +
          94  +
pub(crate) mod shape_query_params_targeting_map_of_pattern_string_operation_output;
          95  +
          96  +
pub(crate) mod shape_query_params_targeting_map_of_set_of_length_string_operation_output;
          97  +
          98  +
pub(crate) mod shape_streaming_blob_operation_input;
          99  +
         100  +
pub(crate) mod shape_streaming_blob_operation_output;
         101  +
         102  +
pub(crate) mod shape_validation_exception;
         103  +
         104  +
pub(crate) mod shape_con_a;
         105  +
         106  +
pub(crate) mod shape_event;
         107  +
         108  +
pub(crate) mod shape_recursive_list;
         109  +
         110  +
pub(crate) mod shape_recursive_shapes_input_output_nested1;
         111  +
         112  +
pub(crate) mod shape_con_b;
         113  +
         114  +
pub(crate) mod shape_con_b_list;
         115  +
         116  +
pub(crate) mod shape_con_b_map;
         117  +
         118  +
pub(crate) mod shape_con_b_set;
         119  +
         120  +
pub(crate) mod shape_constrained_union;
         121  +
         122  +
pub(crate) mod shape_constrained_union_in_output;
         123  +
         124  +
pub(crate) mod shape_event_stream_regular_message;
         125  +
         126  +
pub(crate) mod shape_length_list;
         127  +
         128  +
pub(crate) mod shape_length_list_of_pattern_string;
         129  +
         130  +
pub(crate) mod shape_length_map;
         131  +
         132  +
pub(crate) mod shape_length_set_of_pattern_string;
         133  +
         134  +
pub(crate) mod shape_list_of_length_blob;
         135  +
         136  +
pub(crate) mod shape_list_of_length_pattern_string;
         137  +
         138  +
pub(crate) mod shape_list_of_length_string;
         139  +
         140  +
pub(crate) mod shape_list_of_pattern_string;
         141  +
         142  +
pub(crate) mod shape_list_of_range_byte;
         143  +
         144  +
pub(crate) mod shape_list_of_range_integer;
         145  +
         146  +
pub(crate) mod shape_list_of_range_long;
         147  +
         148  +
pub(crate) mod shape_list_of_range_short;
         149  +
         150  +
pub(crate) mod shape_map_of_length_blob;
         151  +
         152  +
pub(crate) mod shape_map_of_length_pattern_string;
         153  +
         154  +
pub(crate) mod shape_map_of_length_string;
         155  +
         156  +
pub(crate) mod shape_map_of_map_of_list_of_list_of_con_b;
         157  +
         158  +
pub(crate) mod shape_map_of_pattern_string;
         159  +
         160  +
pub(crate) mod shape_map_of_range_byte;
         161  +
         162  +
pub(crate) mod shape_map_of_range_integer;
         163  +
         164  +
pub(crate) mod shape_map_of_range_long;
         165  +
         166  +
pub(crate) mod shape_map_of_range_short;
         167  +
         168  +
pub(crate) mod shape_recursive_shapes_input_output_nested2;
         169  +
         170  +
pub(crate) mod shape_sensitive_length_list;
         171  +
         172  +
pub(crate) mod shape_set_of_length_pattern_string;
         173  +
         174  +
pub(crate) mod shape_set_of_length_string;
         175  +
         176  +
pub(crate) mod shape_set_of_pattern_string;
         177  +
         178  +
pub(crate) mod shape_set_of_range_byte;
         179  +
         180  +
pub(crate) mod shape_set_of_range_integer;
         181  +
         182  +
pub(crate) mod shape_set_of_range_long;
         183  +
         184  +
pub(crate) mod shape_set_of_range_short;
         185  +
         186  +
pub(crate) mod shape_sparse_length_list;
         187  +
         188  +
pub(crate) mod shape_sparse_length_map;
         189  +
         190  +
pub(crate) mod shape_sparse_list;
         191  +
         192  +
pub(crate) mod shape_sparse_map;
         193  +
         194  +
pub(crate) mod shape_transitively_constrained_structure_in_output;
         195  +
         196  +
pub(crate) mod shape_validation_exception_field;
         197  +
         198  +
pub(crate) mod shape_con_b_list_inner;
         199  +
         200  +
pub(crate) mod shape_con_b_set_inner;
         201  +
         202  +
pub(crate) mod shape_map_of_list_of_list_of_con_b;
         203  +
         204  +
pub(crate) mod shape_sensitive_structure;
         205  +
         206  +
pub(crate) mod shape_unique_items_list;

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types-http0x/rust-server-codegen/src/protocol_serde/shape_con_a.rs

@@ -0,1 +0,1150 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) fn de_con_a_payload(
           3  +
    input: &[u8],
           4  +
) -> ::std::result::Result<
           5  +
    crate::model::con_a_internal::Builder,
           6  +
    ::aws_smithy_json::deserialize::error::DeserializeError,
           7  +
> {
           8  +
    let mut tokens_owned =
           9  +
        ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(input))
          10  +
            .peekable();
          11  +
    let tokens = &mut tokens_owned;
          12  +
    let result = crate::protocol_serde::shape_con_a::de_con_a(tokens)?.ok_or_else(|| {
          13  +
        ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          14  +
            "expected payload member value",
          15  +
        )
          16  +
    });
          17  +
    if tokens.next().is_some() {
          18  +
        return Err(
          19  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          20  +
                "found more JSON tokens after completing parsing",
          21  +
            ),
          22  +
        );
          23  +
    }
          24  +
    result
          25  +
}
          26  +
          27  +
pub(crate) fn de_con_a<'a, I>(
          28  +
    tokens: &mut ::std::iter::Peekable<I>,
          29  +
) -> ::std::result::Result<
          30  +
    Option<crate::model::con_a_internal::Builder>,
          31  +
    ::aws_smithy_json::deserialize::error::DeserializeError,
          32  +
>
          33  +
where
          34  +
    I: Iterator<
          35  +
        Item = Result<
          36  +
            ::aws_smithy_json::deserialize::Token<'a>,
          37  +
            ::aws_smithy_json::deserialize::error::DeserializeError,
          38  +
        >,
          39  +
    >,
          40  +
{
          41  +
    match tokens.next().transpose()? {
          42  +
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
          43  +
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
          44  +
            #[allow(unused_mut)]
          45  +
            let mut builder = crate::model::con_a_internal::Builder::default();
          46  +
            loop {
          47  +
                match tokens.next().transpose()? {
          48  +
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
          49  +
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key
          50  +
                        .to_unescaped()?
          51  +
                        .as_ref()
          52  +
                    {
          53  +
                        "conB" => {
          54  +
                            if let Some(v) = crate::protocol_serde::shape_con_b::de_con_b(tokens)? {
          55  +
                                builder = builder.set_con_b(v);
          56  +
                            }
          57  +
                        }
          58  +
                        "optConB" => {
          59  +
                            builder = builder.set_opt_con_b(
          60  +
                                crate::protocol_serde::shape_con_b::de_con_b(tokens)?,
          61  +
                            );
          62  +
                        }
          63  +
                        "lengthString" => {
          64  +
                            builder = builder.set_length_string(
          65  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
          66  +
                                    tokens.next(),
          67  +
                                )?
          68  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
          69  +
                                .transpose()?,
          70  +
                            );
          71  +
                        }
          72  +
                        "minLengthString" => {
          73  +
                            builder = builder.set_min_length_string(
          74  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
          75  +
                                    tokens.next(),
          76  +
                                )?
          77  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
          78  +
                                .transpose()?,
          79  +
                            );
          80  +
                        }
          81  +
                        "maxLengthString" => {
          82  +
                            builder = builder.set_max_length_string(
          83  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
          84  +
                                    tokens.next(),
          85  +
                                )?
          86  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
          87  +
                                .transpose()?,
          88  +
                            );
          89  +
                        }
          90  +
                        "fixedLengthString" => {
          91  +
                            builder = builder.set_fixed_length_string(
          92  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
          93  +
                                    tokens.next(),
          94  +
                                )?
          95  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
          96  +
                                .transpose()?,
          97  +
                            );
          98  +
                        }
          99  +
                        "lengthBlob" => {
         100  +
                            builder = builder.set_length_blob(
         101  +
                                ::aws_smithy_json::deserialize::token::expect_blob_or_null(
         102  +
                                    tokens.next(),
         103  +
                                )?,
         104  +
                            );
         105  +
                        }
         106  +
                        "minLengthBlob" => {
         107  +
                            builder = builder.set_min_length_blob(
         108  +
                                ::aws_smithy_json::deserialize::token::expect_blob_or_null(
         109  +
                                    tokens.next(),
         110  +
                                )?,
         111  +
                            );
         112  +
                        }
         113  +
                        "maxLengthBlob" => {
         114  +
                            builder = builder.set_max_length_blob(
         115  +
                                ::aws_smithy_json::deserialize::token::expect_blob_or_null(
         116  +
                                    tokens.next(),
         117  +
                                )?,
         118  +
                            );
         119  +
                        }
         120  +
                        "fixedLengthBlob" => {
         121  +
                            builder = builder.set_fixed_length_blob(
         122  +
                                ::aws_smithy_json::deserialize::token::expect_blob_or_null(
         123  +
                                    tokens.next(),
         124  +
                                )?,
         125  +
                            );
         126  +
                        }
         127  +
                        "rangeInteger" => {
         128  +
                            if let Some(v) =
         129  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         130  +
                                    tokens.next(),
         131  +
                                )?
         132  +
                                .map(i32::try_from)
         133  +
                                .transpose()?
         134  +
                            {
         135  +
                                builder = builder.set_range_integer(v);
         136  +
                            }
         137  +
                        }
         138  +
                        "minRangeInteger" => {
         139  +
                            if let Some(v) =
         140  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         141  +
                                    tokens.next(),
         142  +
                                )?
         143  +
                                .map(i32::try_from)
         144  +
                                .transpose()?
         145  +
                            {
         146  +
                                builder = builder.set_min_range_integer(v);
         147  +
                            }
         148  +
                        }
         149  +
                        "maxRangeInteger" => {
         150  +
                            if let Some(v) =
         151  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         152  +
                                    tokens.next(),
         153  +
                                )?
         154  +
                                .map(i32::try_from)
         155  +
                                .transpose()?
         156  +
                            {
         157  +
                                builder = builder.set_max_range_integer(v);
         158  +
                            }
         159  +
                        }
         160  +
                        "fixedValueInteger" => {
         161  +
                            if let Some(v) =
         162  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         163  +
                                    tokens.next(),
         164  +
                                )?
         165  +
                                .map(i32::try_from)
         166  +
                                .transpose()?
         167  +
                            {
         168  +
                                builder = builder.set_fixed_value_integer(v);
         169  +
                            }
         170  +
                        }
         171  +
                        "rangeShort" => {
         172  +
                            if let Some(v) =
         173  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         174  +
                                    tokens.next(),
         175  +
                                )?
         176  +
                                .map(i16::try_from)
         177  +
                                .transpose()?
         178  +
                            {
         179  +
                                builder = builder.set_range_short(v);
         180  +
                            }
         181  +
                        }
         182  +
                        "minRangeShort" => {
         183  +
                            if let Some(v) =
         184  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         185  +
                                    tokens.next(),
         186  +
                                )?
         187  +
                                .map(i16::try_from)
         188  +
                                .transpose()?
         189  +
                            {
         190  +
                                builder = builder.set_min_range_short(v);
         191  +
                            }
         192  +
                        }
         193  +
                        "maxRangeShort" => {
         194  +
                            if let Some(v) =
         195  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         196  +
                                    tokens.next(),
         197  +
                                )?
         198  +
                                .map(i16::try_from)
         199  +
                                .transpose()?
         200  +
                            {
         201  +
                                builder = builder.set_max_range_short(v);
         202  +
                            }
         203  +
                        }
         204  +
                        "fixedValueShort" => {
         205  +
                            if let Some(v) =
         206  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         207  +
                                    tokens.next(),
         208  +
                                )?
         209  +
                                .map(i16::try_from)
         210  +
                                .transpose()?
         211  +
                            {
         212  +
                                builder = builder.set_fixed_value_short(v);
         213  +
                            }
         214  +
                        }
         215  +
                        "rangeLong" => {
         216  +
                            if let Some(v) =
         217  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         218  +
                                    tokens.next(),
         219  +
                                )?
         220  +
                                .map(i64::try_from)
         221  +
                                .transpose()?
         222  +
                            {
         223  +
                                builder = builder.set_range_long(v);
         224  +
                            }
         225  +
                        }
         226  +
                        "minRangeLong" => {
         227  +
                            if let Some(v) =
         228  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         229  +
                                    tokens.next(),
         230  +
                                )?
         231  +
                                .map(i64::try_from)
         232  +
                                .transpose()?
         233  +
                            {
         234  +
                                builder = builder.set_min_range_long(v);
         235  +
                            }
         236  +
                        }
         237  +
                        "maxRangeLong" => {
         238  +
                            if let Some(v) =
         239  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         240  +
                                    tokens.next(),
         241  +
                                )?
         242  +
                                .map(i64::try_from)
         243  +
                                .transpose()?
         244  +
                            {
         245  +
                                builder = builder.set_max_range_long(v);
         246  +
                            }
         247  +
                        }
         248  +
                        "fixedValueLong" => {
         249  +
                            if let Some(v) =
         250  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         251  +
                                    tokens.next(),
         252  +
                                )?
         253  +
                                .map(i64::try_from)
         254  +
                                .transpose()?
         255  +
                            {
         256  +
                                builder = builder.set_fixed_value_long(v);
         257  +
                            }
         258  +
                        }
         259  +
                        "rangeByte" => {
         260  +
                            if let Some(v) =
         261  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         262  +
                                    tokens.next(),
         263  +
                                )?
         264  +
                                .map(i8::try_from)
         265  +
                                .transpose()?
         266  +
                            {
         267  +
                                builder = builder.set_range_byte(v);
         268  +
                            }
         269  +
                        }
         270  +
                        "minRangeByte" => {
         271  +
                            if let Some(v) =
         272  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         273  +
                                    tokens.next(),
         274  +
                                )?
         275  +
                                .map(i8::try_from)
         276  +
                                .transpose()?
         277  +
                            {
         278  +
                                builder = builder.set_min_range_byte(v);
         279  +
                            }
         280  +
                        }
         281  +
                        "maxRangeByte" => {
         282  +
                            if let Some(v) =
         283  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         284  +
                                    tokens.next(),
         285  +
                                )?
         286  +
                                .map(i8::try_from)
         287  +
                                .transpose()?
         288  +
                            {
         289  +
                                builder = builder.set_max_range_byte(v);
         290  +
                            }
         291  +
                        }
         292  +
                        "fixedValueByte" => {
         293  +
                            if let Some(v) =
         294  +
                                ::aws_smithy_json::deserialize::token::expect_number_or_null(
         295  +
                                    tokens.next(),
         296  +
                                )?
         297  +
                                .map(i8::try_from)
         298  +
                                .transpose()?
         299  +
                            {
         300  +
                                builder = builder.set_fixed_value_byte(v);
         301  +
                            }
         302  +
                        }
         303  +
                        "conBList" => {
         304  +
                            builder = builder.set_con_b_list(
         305  +
                                crate::protocol_serde::shape_con_b_list::de_con_b_list(tokens)?,
         306  +
                            );
         307  +
                        }
         308  +
                        "lengthList" => {
         309  +
                            builder = builder.set_length_list(
         310  +
                                crate::protocol_serde::shape_length_list::de_length_list(tokens)?,
         311  +
                            );
         312  +
                        }
         313  +
                        "sensitiveLengthList" => {
         314  +
                            builder = builder.set_sensitive_length_list(
         315  +
                                    crate::protocol_serde::shape_sensitive_length_list::de_sensitive_length_list(tokens)?
         316  +
                                );
         317  +
                        }
         318  +
                        "conBSet" => {
         319  +
                            builder = builder.set_con_b_set(
         320  +
                                crate::protocol_serde::shape_con_b_set::de_con_b_set(tokens)?,
         321  +
                            );
         322  +
                        }
         323  +
                        "conBMap" => {
         324  +
                            builder = builder.set_con_b_map(
         325  +
                                crate::protocol_serde::shape_con_b_map::de_con_b_map(tokens)?,
         326  +
                            );
         327  +
                        }
         328  +
                        "lengthMap" => {
         329  +
                            builder = builder.set_length_map(
         330  +
                                crate::protocol_serde::shape_length_map::de_length_map(tokens)?,
         331  +
                            );
         332  +
                        }
         333  +
                        "mapOfMapOfListOfListOfConB" => {
         334  +
                            builder = builder.set_map_of_map_of_list_of_list_of_con_b(
         335  +
                                    crate::protocol_serde::shape_map_of_map_of_list_of_list_of_con_b::de_map_of_map_of_list_of_list_of_con_b(tokens)?
         336  +
                                );
         337  +
                        }
         338  +
                        "sparseMap" => {
         339  +
                            builder = builder.set_sparse_map(
         340  +
                                crate::protocol_serde::shape_sparse_map::de_sparse_map(tokens)?,
         341  +
                            );
         342  +
                        }
         343  +
                        "sparseList" => {
         344  +
                            builder = builder.set_sparse_list(
         345  +
                                crate::protocol_serde::shape_sparse_list::de_sparse_list(tokens)?,
         346  +
                            );
         347  +
                        }
         348  +
                        "sparseLengthMap" => {
         349  +
                            builder = builder.set_sparse_length_map(
         350  +
                                    crate::protocol_serde::shape_sparse_length_map::de_sparse_length_map(tokens)?
         351  +
                                );
         352  +
                        }
         353  +
                        "sparseLengthList" => {
         354  +
                            builder = builder.set_sparse_length_list(
         355  +
                                    crate::protocol_serde::shape_sparse_length_list::de_sparse_length_list(tokens)?
         356  +
                                );
         357  +
                        }
         358  +
                        "constrainedUnion" => {
         359  +
                            builder = builder.set_constrained_union(
         360  +
                                    crate::protocol_serde::shape_constrained_union::de_constrained_union(tokens)?
         361  +
                                );
         362  +
                        }
         363  +
                        "enumString" => {
         364  +
                            builder = builder.set_enum_string(
         365  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
         366  +
                                    tokens.next(),
         367  +
                                )?
         368  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
         369  +
                                .transpose()?,
         370  +
                            );
         371  +
                        }
         372  +
                        "listOfLengthString" => {
         373  +
                            builder = builder.set_list_of_length_string(
         374  +
                                    crate::protocol_serde::shape_list_of_length_string::de_list_of_length_string(tokens)?
         375  +
                                );
         376  +
                        }
         377  +
                        "setOfLengthString" => {
         378  +
                            builder = builder.set_set_of_length_string(
         379  +
                                    crate::protocol_serde::shape_set_of_length_string::de_set_of_length_string(tokens)?
         380  +
                                );
         381  +
                        }
         382  +
                        "mapOfLengthString" => {
         383  +
                            builder = builder.set_map_of_length_string(
         384  +
                                    crate::protocol_serde::shape_map_of_length_string::de_map_of_length_string(tokens)?
         385  +
                                );
         386  +
                        }
         387  +
                        "listOfLengthBlob" => {
         388  +
                            builder = builder.set_list_of_length_blob(
         389  +
                                    crate::protocol_serde::shape_list_of_length_blob::de_list_of_length_blob(tokens)?
         390  +
                                );
         391  +
                        }
         392  +
                        "mapOfLengthBlob" => {
         393  +
                            builder = builder.set_map_of_length_blob(
         394  +
                                    crate::protocol_serde::shape_map_of_length_blob::de_map_of_length_blob(tokens)?
         395  +
                                );
         396  +
                        }
         397  +
                        "listOfRangeInteger" => {
         398  +
                            builder = builder.set_list_of_range_integer(
         399  +
                                    crate::protocol_serde::shape_list_of_range_integer::de_list_of_range_integer(tokens)?
         400  +
                                );
         401  +
                        }
         402  +
                        "setOfRangeInteger" => {
         403  +
                            builder = builder.set_set_of_range_integer(
         404  +
                                    crate::protocol_serde::shape_set_of_range_integer::de_set_of_range_integer(tokens)?
         405  +
                                );
         406  +
                        }
         407  +
                        "mapOfRangeInteger" => {
         408  +
                            builder = builder.set_map_of_range_integer(
         409  +
                                    crate::protocol_serde::shape_map_of_range_integer::de_map_of_range_integer(tokens)?
         410  +
                                );
         411  +
                        }
         412  +
                        "listOfRangeShort" => {
         413  +
                            builder = builder.set_list_of_range_short(
         414  +
                                    crate::protocol_serde::shape_list_of_range_short::de_list_of_range_short(tokens)?
         415  +
                                );
         416  +
                        }
         417  +
                        "setOfRangeShort" => {
         418  +
                            builder = builder.set_set_of_range_short(
         419  +
                                    crate::protocol_serde::shape_set_of_range_short::de_set_of_range_short(tokens)?
         420  +
                                );
         421  +
                        }
         422  +
                        "mapOfRangeShort" => {
         423  +
                            builder = builder.set_map_of_range_short(
         424  +
                                    crate::protocol_serde::shape_map_of_range_short::de_map_of_range_short(tokens)?
         425  +
                                );
         426  +
                        }
         427  +
                        "listOfRangeLong" => {
         428  +
                            builder = builder.set_list_of_range_long(
         429  +
                                    crate::protocol_serde::shape_list_of_range_long::de_list_of_range_long(tokens)?
         430  +
                                );
         431  +
                        }
         432  +
                        "setOfRangeLong" => {
         433  +
                            builder = builder.set_set_of_range_long(
         434  +
                                    crate::protocol_serde::shape_set_of_range_long::de_set_of_range_long(tokens)?
         435  +
                                );
         436  +
                        }
         437  +
                        "mapOfRangeLong" => {
         438  +
                            builder = builder.set_map_of_range_long(
         439  +
                                    crate::protocol_serde::shape_map_of_range_long::de_map_of_range_long(tokens)?
         440  +
                                );
         441  +
                        }
         442  +
                        "listOfRangeByte" => {
         443  +
                            builder = builder.set_list_of_range_byte(
         444  +
                                    crate::protocol_serde::shape_list_of_range_byte::de_list_of_range_byte(tokens)?
         445  +
                                );
         446  +
                        }
         447  +
                        "setOfRangeByte" => {
         448  +
                            builder = builder.set_set_of_range_byte(
         449  +
                                    crate::protocol_serde::shape_set_of_range_byte::de_set_of_range_byte(tokens)?
         450  +
                                );
         451  +
                        }
         452  +
                        "mapOfRangeByte" => {
         453  +
                            builder = builder.set_map_of_range_byte(
         454  +
                                    crate::protocol_serde::shape_map_of_range_byte::de_map_of_range_byte(tokens)?
         455  +
                                );
         456  +
                        }
         457  +
                        "nonStreamingBlob" => {
         458  +
                            builder = builder.set_non_streaming_blob(
         459  +
                                ::aws_smithy_json::deserialize::token::expect_blob_or_null(
         460  +
                                    tokens.next(),
         461  +
                                )?,
         462  +
                            );
         463  +
                        }
         464  +
                        "patternString" => {
         465  +
                            builder = builder.set_pattern_string(
         466  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
         467  +
                                    tokens.next(),
         468  +
                                )?
         469  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
         470  +
                                .transpose()?,
         471  +
                            );
         472  +
                        }
         473  +
                        "mapOfPatternString" => {
         474  +
                            builder = builder.set_map_of_pattern_string(
         475  +
                                    crate::protocol_serde::shape_map_of_pattern_string::de_map_of_pattern_string(tokens)?
         476  +
                                );
         477  +
                        }
         478  +
                        "listOfPatternString" => {
         479  +
                            builder = builder.set_list_of_pattern_string(
         480  +
                                    crate::protocol_serde::shape_list_of_pattern_string::de_list_of_pattern_string(tokens)?
         481  +
                                );
         482  +
                        }
         483  +
                        "setOfPatternString" => {
         484  +
                            builder = builder.set_set_of_pattern_string(
         485  +
                                    crate::protocol_serde::shape_set_of_pattern_string::de_set_of_pattern_string(tokens)?
         486  +
                                );
         487  +
                        }
         488  +
                        "lengthLengthPatternString" => {
         489  +
                            builder = builder.set_length_length_pattern_string(
         490  +
                                ::aws_smithy_json::deserialize::token::expect_string_or_null(
         491  +
                                    tokens.next(),
         492  +
                                )?
         493  +
                                .map(|s| s.to_unescaped().map(|u| u.into_owned()))
         494  +
                                .transpose()?,
         495  +
                            );
         496  +
                        }
         497  +
                        "mapOfLengthPatternString" => {
         498  +
                            builder = builder.set_map_of_length_pattern_string(
         499  +
                                    crate::protocol_serde::shape_map_of_length_pattern_string::de_map_of_length_pattern_string(tokens)?
         500  +
                                );
         501  +
                        }
         502  +
                        "listOfLengthPatternString" => {
         503  +
                            builder = builder.set_list_of_length_pattern_string(
         504  +
                                    crate::protocol_serde::shape_list_of_length_pattern_string::de_list_of_length_pattern_string(tokens)?
         505  +
                                );
         506  +
                        }
         507  +
                        "setOfLengthPatternString" => {
         508  +
                            builder = builder.set_set_of_length_pattern_string(
         509  +
                                    crate::protocol_serde::shape_set_of_length_pattern_string::de_set_of_length_pattern_string(tokens)?
         510  +
                                );
         511  +
                        }
         512  +
                        "lengthListOfPatternString" => {
         513  +
                            builder = builder.set_length_list_of_pattern_string(
         514  +
                                    crate::protocol_serde::shape_length_list_of_pattern_string::de_length_list_of_pattern_string(tokens)?
         515  +
                                );
         516  +
                        }
         517  +
                        "lengthSetOfPatternString" => {
         518  +
                            builder = builder.set_length_set_of_pattern_string(
         519  +
                                    crate::protocol_serde::shape_length_set_of_pattern_string::de_length_set_of_pattern_string(tokens)?
         520  +
                                );
         521  +
                        }
         522  +
                        _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
         523  +
                    },
         524  +
                    other => {
         525  +
                        return Err(
         526  +
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         527  +
                                format!("expected object key or end object, found: {other:?}"),
         528  +
                            ),
         529  +
                        )
         530  +
                    }
         531  +
                }
         532  +
            }
         533  +
            Ok(Some(builder))
         534  +
        }
         535  +
        _ => Err(
         536  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         537  +
                "expected start object or null",
         538  +
            ),
         539  +
        ),
         540  +
    }
         541  +
}
         542  +
         543  +
pub fn ser_con_a(
         544  +
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
         545  +
    input: &crate::model::ConA,
         546  +
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
         547  +
    {
         548  +
        #[allow(unused_mut)]
         549  +
        let mut object_1 = object.key("conB").start_object();
         550  +
        crate::protocol_serde::shape_con_b::ser_con_b(&mut object_1, &input.con_b)?;
         551  +
        object_1.finish();
         552  +
    }
         553  +
    if let Some(var_2) = &input.opt_con_b {
         554  +
        #[allow(unused_mut)]
         555  +
        let mut object_3 = object.key("optConB").start_object();
         556  +
        crate::protocol_serde::shape_con_b::ser_con_b(&mut object_3, var_2)?;
         557  +
        object_3.finish();
         558  +
    }
         559  +
    if let Some(var_4) = &input.length_string {
         560  +
        object.key("lengthString").string(var_4.as_str());
         561  +
    }
         562  +
    if let Some(var_5) = &input.min_length_string {
         563  +
        object.key("minLengthString").string(var_5.as_str());
         564  +
    }
         565  +
    if let Some(var_6) = &input.max_length_string {
         566  +
        object.key("maxLengthString").string(var_6.as_str());
         567  +
    }
         568  +
    if let Some(var_7) = &input.fixed_length_string {
         569  +
        object.key("fixedLengthString").string(var_7.as_str());
         570  +
    }
         571  +
    if let Some(var_8) = &input.length_blob {
         572  +
        object
         573  +
            .key("lengthBlob")
         574  +
            .string_unchecked(&::aws_smithy_types::base64::encode(var_8));
         575  +
    }
         576  +
    if let Some(var_9) = &input.min_length_blob {
         577  +
        object
         578  +
            .key("minLengthBlob")
         579  +
            .string_unchecked(&::aws_smithy_types::base64::encode(var_9));
         580  +
    }
         581  +
    if let Some(var_10) = &input.max_length_blob {
         582  +
        object
         583  +
            .key("maxLengthBlob")
         584  +
            .string_unchecked(&::aws_smithy_types::base64::encode(var_10));
         585  +
    }
         586  +
    if let Some(var_11) = &input.fixed_length_blob {
         587  +
        object
         588  +
            .key("fixedLengthBlob")
         589  +
            .string_unchecked(&::aws_smithy_types::base64::encode(var_11));
         590  +
    }
         591  +
    if input.range_integer != 0 {
         592  +
        object.key("rangeInteger").number(
         593  +
            #[allow(clippy::useless_conversion)]
         594  +
            ::aws_smithy_types::Number::NegInt((input.range_integer).into()),
         595  +
        );
         596  +
    }
         597  +
    if input.min_range_integer != 0 {
         598  +
        object.key("minRangeInteger").number(
         599  +
            #[allow(clippy::useless_conversion)]
         600  +
            ::aws_smithy_types::Number::NegInt((input.min_range_integer).into()),
         601  +
        );
         602  +
    }
         603  +
    if input.max_range_integer != 0 {
         604  +
        object.key("maxRangeInteger").number(
         605  +
            #[allow(clippy::useless_conversion)]
         606  +
            ::aws_smithy_types::Number::NegInt((input.max_range_integer).into()),
         607  +
        );
         608  +
    }
         609  +
    if input.fixed_value_integer != 0 {
         610  +
        object.key("fixedValueInteger").number(
         611  +
            #[allow(clippy::useless_conversion)]
         612  +
            ::aws_smithy_types::Number::NegInt((input.fixed_value_integer).into()),
         613  +
        );
         614  +
    }
         615  +
    if input.range_short != 0 {
         616  +
        object.key("rangeShort").number(
         617  +
            #[allow(clippy::useless_conversion)]
         618  +
            ::aws_smithy_types::Number::NegInt((input.range_short).into()),
         619  +
        );
         620  +
    }
         621  +
    if input.min_range_short != 0 {
         622  +
        object.key("minRangeShort").number(
         623  +
            #[allow(clippy::useless_conversion)]
         624  +
            ::aws_smithy_types::Number::NegInt((input.min_range_short).into()),
         625  +
        );
         626  +
    }
         627  +
    if input.max_range_short != 0 {
         628  +
        object.key("maxRangeShort").number(
         629  +
            #[allow(clippy::useless_conversion)]
         630  +
            ::aws_smithy_types::Number::NegInt((input.max_range_short).into()),
         631  +
        );
         632  +
    }
         633  +
    if input.fixed_value_short != 0 {
         634  +
        object.key("fixedValueShort").number(
         635  +
            #[allow(clippy::useless_conversion)]
         636  +
            ::aws_smithy_types::Number::NegInt((input.fixed_value_short).into()),
         637  +
        );
         638  +
    }
         639  +
    if input.range_long != 0 {
         640  +
        object.key("rangeLong").number(
         641  +
            #[allow(clippy::useless_conversion)]
         642  +
            ::aws_smithy_types::Number::NegInt((input.range_long).into()),
         643  +
        );
         644  +
    }
         645  +
    if input.min_range_long != 0 {
         646  +
        object.key("minRangeLong").number(
         647  +
            #[allow(clippy::useless_conversion)]
         648  +
            ::aws_smithy_types::Number::NegInt((input.min_range_long).into()),
         649  +
        );
         650  +
    }
         651  +
    if input.max_range_long != 0 {
         652  +
        object.key("maxRangeLong").number(
         653  +
            #[allow(clippy::useless_conversion)]
         654  +
            ::aws_smithy_types::Number::NegInt((input.max_range_long).into()),
         655  +
        );
         656  +
    }
         657  +
    if input.fixed_value_long != 0 {
         658  +
        object.key("fixedValueLong").number(
         659  +
            #[allow(clippy::useless_conversion)]
         660  +
            ::aws_smithy_types::Number::NegInt((input.fixed_value_long).into()),
         661  +
        );
         662  +
    }
         663  +
    if input.range_byte != 0 {
         664  +
        object.key("rangeByte").number(
         665  +
            #[allow(clippy::useless_conversion)]
         666  +
            ::aws_smithy_types::Number::NegInt((input.range_byte).into()),
         667  +
        );
         668  +
    }
         669  +
    if input.min_range_byte != 0 {
         670  +
        object.key("minRangeByte").number(
         671  +
            #[allow(clippy::useless_conversion)]
         672  +
            ::aws_smithy_types::Number::NegInt((input.min_range_byte).into()),
         673  +
        );
         674  +
    }
         675  +
    if input.max_range_byte != 0 {
         676  +
        object.key("maxRangeByte").number(
         677  +
            #[allow(clippy::useless_conversion)]
         678  +
            ::aws_smithy_types::Number::NegInt((input.max_range_byte).into()),
         679  +
        );
         680  +
    }
         681  +
    if input.fixed_value_byte != 0 {
         682  +
        object.key("fixedValueByte").number(
         683  +
            #[allow(clippy::useless_conversion)]
         684  +
            ::aws_smithy_types::Number::NegInt((input.fixed_value_byte).into()),
         685  +
        );
         686  +
    }
         687  +
    if let Some(var_12) = &input.con_b_list {
         688  +
        let mut array_13 = object.key("conBList").start_array();
         689  +
        for item_14 in var_12 {
         690  +
            {
         691  +
                let mut array_15 = array_13.value().start_array();
         692  +
                for item_16 in item_14 {
         693  +
                    {
         694  +
                        #[allow(unused_mut)]
         695  +
                        let mut object_17 = array_15.value().start_object();
         696  +
                        crate::protocol_serde::shape_con_b::ser_con_b(&mut object_17, item_16)?;
         697  +
                        object_17.finish();
         698  +
                    }
         699  +
                }
         700  +
                array_15.finish();
         701  +
            }
         702  +
        }
         703  +
        array_13.finish();
         704  +
    }
         705  +
    if let Some(var_18) = &input.length_list {
         706  +
        let mut array_19 = object.key("lengthList").start_array();
         707  +
        for item_20 in var_18 {
         708  +
            {
         709  +
                array_19.value().string(item_20.as_str());
         710  +
            }
         711  +
        }
         712  +
        array_19.finish();
         713  +
    }
         714  +
    if let Some(var_21) = &input.sensitive_length_list {
         715  +
        let mut array_22 = object.key("sensitiveLengthList").start_array();
         716  +
        for item_23 in var_21 {
         717  +
            {
         718  +
                #[allow(unused_mut)]
         719  +
                let mut object_24 = array_22.value().start_object();
         720  +
                crate::protocol_serde::shape_sensitive_structure::ser_sensitive_structure(
         721  +
                    &mut object_24,
         722  +
                    item_23,
         723  +
                )?;
         724  +
                object_24.finish();
         725  +
            }
         726  +
        }
         727  +
        array_22.finish();
         728  +
    }
         729  +
    if let Some(var_25) = &input.con_b_set {
         730  +
        let mut array_26 = object.key("conBSet").start_array();
         731  +
        for item_27 in var_25 {
         732  +
            {
         733  +
                let mut array_28 = array_26.value().start_array();
         734  +
                for item_29 in item_27 {
         735  +
                    {
         736  +
                        array_28.value().string(item_29.as_str());
         737  +
                    }
         738  +
                }
         739  +
                array_28.finish();
         740  +
            }
         741  +
        }
         742  +
        array_26.finish();
         743  +
    }
         744  +
    if let Some(var_30) = &input.con_b_map {
         745  +
        #[allow(unused_mut)]
         746  +
        let mut object_31 = object.key("conBMap").start_object();
         747  +
        for (key_32, value_33) in var_30 {
         748  +
            {
         749  +
                object_31.key(key_32.as_str()).string(value_33.as_str());
         750  +
            }
         751  +
        }
         752  +
        object_31.finish();
         753  +
    }
         754  +
    if let Some(var_34) = &input.length_map {
         755  +
        #[allow(unused_mut)]
         756  +
        let mut object_35 = object.key("lengthMap").start_object();
         757  +
        for (key_36, value_37) in var_34 {
         758  +
            {
         759  +
                object_35.key(key_36.as_str()).string(value_37.as_str());
         760  +
            }
         761  +
        }
         762  +
        object_35.finish();
         763  +
    }
         764  +
    if let Some(var_38) = &input.map_of_map_of_list_of_list_of_con_b {
         765  +
        #[allow(unused_mut)]
         766  +
        let mut object_39 = object.key("mapOfMapOfListOfListOfConB").start_object();
         767  +
        for (key_40, value_41) in var_38 {
         768  +
            {
         769  +
                #[allow(unused_mut)]
         770  +
                let mut object_42 = object_39.key(key_40.as_str()).start_object();
         771  +
                for (key_43, value_44) in value_41 {
         772  +
                    {
         773  +
                        let mut array_45 = object_42.key(key_43.as_str()).start_array();
         774  +
                        for item_46 in value_44 {
         775  +
                            {
         776  +
                                let mut array_47 = array_45.value().start_array();
         777  +
                                for item_48 in item_46 {
         778  +
                                    {
         779  +
                                        #[allow(unused_mut)]
         780  +
                                        let mut object_49 = array_47.value().start_object();
         781  +
                                        crate::protocol_serde::shape_con_b::ser_con_b(
         782  +
                                            &mut object_49,
         783  +
                                            item_48,
         784  +
                                        )?;
         785  +
                                        object_49.finish();
         786  +
                                    }
         787  +
                                }
         788  +
                                array_47.finish();
         789  +
                            }
         790  +
                        }
         791  +
                        array_45.finish();
         792  +
                    }
         793  +
                }
         794  +
                object_42.finish();
         795  +
            }
         796  +
        }
         797  +
        object_39.finish();
         798  +
    }
         799  +
    if let Some(var_50) = &input.sparse_map {
         800  +
        #[allow(unused_mut)]
         801  +
        let mut object_51 = object.key("sparseMap").start_object();
         802  +
        for (key_52, value_53) in var_50 {
         803  +
            if let Some(var_54) = value_53 {
         804  +
                let mut array_55 = object_51.key(key_52.as_str()).start_array();
         805  +
                for item_56 in var_54 {
         806  +
                    {
         807  +
                        array_55.value().string(item_56.as_str());
         808  +
                    }
         809  +
                }
         810  +
                array_55.finish();
         811  +
            } else {
         812  +
                object_51.key(key_52.as_str()).null();
         813  +
            }
         814  +
        }
         815  +
        object_51.finish();
         816  +
    }
         817  +
    if let Some(var_57) = &input.sparse_list {
         818  +
        let mut array_58 = object.key("sparseList").start_array();
         819  +
        for item_59 in var_57 {
         820  +
            if let Some(var_60) = item_59 {
         821  +
                array_58.value().string(var_60.as_str());
         822  +
            } else {
         823  +
                array_58.value().null();
         824  +
            }
         825  +
        }
         826  +
        array_58.finish();
         827  +
    }
         828  +
    if let Some(var_61) = &input.sparse_length_map {
         829  +
        #[allow(unused_mut)]
         830  +
        let mut object_62 = object.key("sparseLengthMap").start_object();
         831  +
        for (key_63, value_64) in var_61 {
         832  +
            if let Some(var_65) = value_64 {
         833  +
                object_62.key(key_63.as_str()).string(var_65.as_str());
         834  +
            } else {
         835  +
                object_62.key(key_63.as_str()).null();
         836  +
            }
         837  +
        }
         838  +
        object_62.finish();
         839  +
    }
         840  +
    if let Some(var_66) = &input.sparse_length_list {
         841  +
        let mut array_67 = object.key("sparseLengthList").start_array();
         842  +
        for item_68 in var_66 {
         843  +
            if let Some(var_69) = item_68 {
         844  +
                array_67.value().string(var_69.as_str());
         845  +
            } else {
         846  +
                array_67.value().null();
         847  +
            }
         848  +
        }
         849  +
        array_67.finish();
         850  +
    }
         851  +
    if let Some(var_70) = &input.constrained_union {
         852  +
        #[allow(unused_mut)]
         853  +
        let mut object_71 = object.key("constrainedUnion").start_object();
         854  +
        crate::protocol_serde::shape_constrained_union::ser_constrained_union(
         855  +
            &mut object_71,
         856  +
            var_70,
         857  +
        )?;
         858  +
        object_71.finish();
         859  +
    }
         860  +
    if let Some(var_72) = &input.enum_string {
         861  +
        object.key("enumString").string(var_72.as_str());
         862  +
    }
         863  +
    if let Some(var_73) = &input.list_of_length_string {
         864  +
        let mut array_74 = object.key("listOfLengthString").start_array();
         865  +
        for item_75 in var_73 {
         866  +
            {
         867  +
                array_74.value().string(item_75.as_str());
         868  +
            }
         869  +
        }
         870  +
        array_74.finish();
         871  +
    }
         872  +
    if let Some(var_76) = &input.set_of_length_string {
         873  +
        let mut array_77 = object.key("setOfLengthString").start_array();
         874  +
        for item_78 in var_76 {
         875  +
            {
         876  +
                array_77.value().string(item_78.as_str());
         877  +
            }
         878  +
        }
         879  +
        array_77.finish();
         880  +
    }
         881  +
    if let Some(var_79) = &input.map_of_length_string {
         882  +
        #[allow(unused_mut)]
         883  +
        let mut object_80 = object.key("mapOfLengthString").start_object();
         884  +
        for (key_81, value_82) in var_79 {
         885  +
            {
         886  +
                object_80.key(key_81.as_str()).string(value_82.as_str());
         887  +
            }
         888  +
        }
         889  +
        object_80.finish();
         890  +
    }
         891  +
    if let Some(var_83) = &input.list_of_length_blob {
         892  +
        let mut array_84 = object.key("listOfLengthBlob").start_array();
         893  +
        for item_85 in var_83 {
         894  +
            {
         895  +
                array_84
         896  +
                    .value()
         897  +
                    .string_unchecked(&::aws_smithy_types::base64::encode(item_85));
         898  +
            }
         899  +
        }
         900  +
        array_84.finish();
         901  +
    }
         902  +
    if let Some(var_86) = &input.map_of_length_blob {
         903  +
        #[allow(unused_mut)]
         904  +
        let mut object_87 = object.key("mapOfLengthBlob").start_object();
         905  +
        for (key_88, value_89) in var_86 {
         906  +
            {
         907  +
                object_87
         908  +
                    .key(key_88.as_str())
         909  +
                    .string_unchecked(&::aws_smithy_types::base64::encode(value_89));
         910  +
            }
         911  +
        }
         912  +
        object_87.finish();
         913  +
    }
         914  +
    if let Some(var_90) = &input.list_of_range_integer {
         915  +
        let mut array_91 = object.key("listOfRangeInteger").start_array();
         916  +
        for item_92 in var_90 {
         917  +
            {
         918  +
                array_91.value().number(
         919  +
                    #[allow(clippy::useless_conversion)]
         920  +
                    ::aws_smithy_types::Number::NegInt((*item_92).into()),
         921  +
                );
         922  +
            }
         923  +
        }
         924  +
        array_91.finish();
         925  +
    }
         926  +
    if let Some(var_93) = &input.set_of_range_integer {
         927  +
        let mut array_94 = object.key("setOfRangeInteger").start_array();
         928  +
        for item_95 in var_93 {
         929  +
            {
         930  +
                array_94.value().number(
         931  +
                    #[allow(clippy::useless_conversion)]
         932  +
                    ::aws_smithy_types::Number::NegInt((*item_95).into()),
         933  +
                );
         934  +
            }
         935  +
        }
         936  +
        array_94.finish();
         937  +
    }
         938  +
    if let Some(var_96) = &input.map_of_range_integer {
         939  +
        #[allow(unused_mut)]
         940  +
        let mut object_97 = object.key("mapOfRangeInteger").start_object();
         941  +
        for (key_98, value_99) in var_96 {
         942  +
            {
         943  +
                object_97.key(key_98.as_str()).number(
         944  +
                    #[allow(clippy::useless_conversion)]
         945  +
                    ::aws_smithy_types::Number::NegInt((*value_99).into()),
         946  +
                );
         947  +
            }
         948  +
        }
         949  +
        object_97.finish();
         950  +
    }
         951  +
    if let Some(var_100) = &input.list_of_range_short {
         952  +
        let mut array_101 = object.key("listOfRangeShort").start_array();
         953  +
        for item_102 in var_100 {
         954  +
            {
         955  +
                array_101.value().number(
         956  +
                    #[allow(clippy::useless_conversion)]
         957  +
                    ::aws_smithy_types::Number::NegInt((*item_102).into()),
         958  +
                );
         959  +
            }
         960  +
        }
         961  +
        array_101.finish();
         962  +
    }
         963  +
    if let Some(var_103) = &input.set_of_range_short {
         964  +
        let mut array_104 = object.key("setOfRangeShort").start_array();
         965  +
        for item_105 in var_103 {
         966  +
            {
         967  +
                array_104.value().number(
         968  +
                    #[allow(clippy::useless_conversion)]
         969  +
                    ::aws_smithy_types::Number::NegInt((*item_105).into()),
         970  +
                );
         971  +
            }
         972  +
        }
         973  +
        array_104.finish();
         974  +
    }
         975  +
    if let Some(var_106) = &input.map_of_range_short {
         976  +
        #[allow(unused_mut)]
         977  +
        let mut object_107 = object.key("mapOfRangeShort").start_object();
         978  +
        for (key_108, value_109) in var_106 {
         979  +
            {
         980  +
                object_107.key(key_108.as_str()).number(
         981  +
                    #[allow(clippy::useless_conversion)]
         982  +
                    ::aws_smithy_types::Number::NegInt((*value_109).into()),
         983  +
                );
         984  +
            }
         985  +
        }
         986  +
        object_107.finish();
         987  +
    }
         988  +
    if let Some(var_110) = &input.list_of_range_long {
         989  +
        let mut array_111 = object.key("listOfRangeLong").start_array();
         990  +
        for item_112 in var_110 {
         991  +
            {
         992  +
                array_111.value().number(
         993  +
                    #[allow(clippy::useless_conversion)]
         994  +
                    ::aws_smithy_types::Number::NegInt((*item_112).into()),
         995  +
                );
         996  +
            }
         997  +
        }
         998  +
        array_111.finish();
         999  +
    }
        1000  +
    if let Some(var_113) = &input.set_of_range_long {
        1001  +
        let mut array_114 = object.key("setOfRangeLong").start_array();
        1002  +
        for item_115 in var_113 {
        1003  +
            {
        1004  +
                array_114.value().number(
        1005  +
                    #[allow(clippy::useless_conversion)]
        1006  +
                    ::aws_smithy_types::Number::NegInt((*item_115).into()),
        1007  +
                );
        1008  +
            }
        1009  +
        }
        1010  +
        array_114.finish();
        1011  +
    }
        1012  +
    if let Some(var_116) = &input.map_of_range_long {
        1013  +
        #[allow(unused_mut)]
        1014  +
        let mut object_117 = object.key("mapOfRangeLong").start_object();
        1015  +
        for (key_118, value_119) in var_116 {
        1016  +
            {
        1017  +
                object_117.key(key_118.as_str()).number(
        1018  +
                    #[allow(clippy::useless_conversion)]
        1019  +
                    ::aws_smithy_types::Number::NegInt((*value_119).into()),
        1020  +
                );
        1021  +
            }
        1022  +
        }
        1023  +
        object_117.finish();
        1024  +
    }
        1025  +
    if let Some(var_120) = &input.list_of_range_byte {
        1026  +
        let mut array_121 = object.key("listOfRangeByte").start_array();
        1027  +
        for item_122 in var_120 {
        1028  +
            {
        1029  +
                array_121.value().number(
        1030  +
                    #[allow(clippy::useless_conversion)]
        1031  +
                    ::aws_smithy_types::Number::NegInt((*item_122).into()),
        1032  +
                );
        1033  +
            }
        1034  +
        }
        1035  +
        array_121.finish();
        1036  +
    }
        1037  +
    if let Some(var_123) = &input.set_of_range_byte {
        1038  +
        let mut array_124 = object.key("setOfRangeByte").start_array();
        1039  +
        for item_125 in var_123 {
        1040  +
            {
        1041  +
                array_124.value().number(
        1042  +
                    #[allow(clippy::useless_conversion)]
        1043  +
                    ::aws_smithy_types::Number::NegInt((*item_125).into()),
        1044  +
                );
        1045  +
            }
        1046  +
        }
        1047  +
        array_124.finish();
        1048  +
    }
        1049  +
    if let Some(var_126) = &input.map_of_range_byte {
        1050  +
        #[allow(unused_mut)]
        1051  +
        let mut object_127 = object.key("mapOfRangeByte").start_object();
        1052  +
        for (key_128, value_129) in var_126 {
        1053  +
            {
        1054  +
                object_127.key(key_128.as_str()).number(
        1055  +
                    #[allow(clippy::useless_conversion)]
        1056  +
                    ::aws_smithy_types::Number::NegInt((*value_129).into()),
        1057  +
                );
        1058  +
            }
        1059  +
        }
        1060  +
        object_127.finish();
        1061  +
    }
        1062  +
    if let Some(var_130) = &input.non_streaming_blob {
        1063  +
        object
        1064  +
            .key("nonStreamingBlob")
        1065  +
            .string_unchecked(&::aws_smithy_types::base64::encode(var_130));
        1066  +
    }
        1067  +
    if let Some(var_131) = &input.pattern_string {
        1068  +
        object.key("patternString").string(var_131.as_str());
        1069  +
    }
        1070  +
    if let Some(var_132) = &input.map_of_pattern_string {
        1071  +
        #[allow(unused_mut)]
        1072  +
        let mut object_133 = object.key("mapOfPatternString").start_object();
        1073  +
        for (key_134, value_135) in var_132 {
        1074  +
            {
        1075  +
                object_133.key(key_134.as_str()).string(value_135.as_str());
        1076  +
            }
        1077  +
        }
        1078  +
        object_133.finish();
        1079  +
    }
        1080  +
    if let Some(var_136) = &input.list_of_pattern_string {
        1081  +
        let mut array_137 = object.key("listOfPatternString").start_array();
        1082  +
        for item_138 in var_136 {
        1083  +
            {
        1084  +
                array_137.value().string(item_138.as_str());
        1085  +
            }
        1086  +
        }
        1087  +
        array_137.finish();
        1088  +
    }
        1089  +
    if let Some(var_139) = &input.set_of_pattern_string {
        1090  +
        let mut array_140 = object.key("setOfPatternString").start_array();
        1091  +
        for item_141 in var_139 {
        1092  +
            {
        1093  +
                array_140.value().string(item_141.as_str());
        1094  +
            }
        1095  +
        }
        1096  +
        array_140.finish();
        1097  +
    }
        1098  +
    if let Some(var_142) = &input.length_length_pattern_string {
        1099  +
        object
        1100  +
            .key("lengthLengthPatternString")
        1101  +
            .string(var_142.as_str());
        1102  +
    }
        1103  +
    if let Some(var_143) = &input.map_of_length_pattern_string {
        1104  +
        #[allow(unused_mut)]
        1105  +
        let mut object_144 = object.key("mapOfLengthPatternString").start_object();
        1106  +
        for (key_145, value_146) in var_143 {
        1107  +
            {
        1108  +
                object_144.key(key_145.as_str()).string(value_146.as_str());
        1109  +
            }
        1110  +
        }
        1111  +
        object_144.finish();
        1112  +
    }
        1113  +
    if let Some(var_147) = &input.list_of_length_pattern_string {
        1114  +
        let mut array_148 = object.key("listOfLengthPatternString").start_array();
        1115  +
        for item_149 in var_147 {
        1116  +
            {
        1117  +
                array_148.value().string(item_149.as_str());
        1118  +
            }
        1119  +
        }
        1120  +
        array_148.finish();
        1121  +
    }
        1122  +
    if let Some(var_150) = &input.set_of_length_pattern_string {
        1123  +
        let mut array_151 = object.key("setOfLengthPatternString").start_array();
        1124  +
        for item_152 in var_150 {
        1125  +
            {
        1126  +
                array_151.value().string(item_152.as_str());
        1127  +
            }
        1128  +
        }
        1129  +
        array_151.finish();
        1130  +
    }
        1131  +
    if let Some(var_153) = &input.length_list_of_pattern_string {
        1132  +
        let mut array_154 = object.key("lengthListOfPatternString").start_array();
        1133  +
        for item_155 in var_153 {
        1134  +
            {
        1135  +
                array_154.value().string(item_155.as_str());
        1136  +
            }
        1137  +
        }
        1138  +
        array_154.finish();
        1139  +
    }
        1140  +
    if let Some(var_156) = &input.length_set_of_pattern_string {
        1141  +
        let mut array_157 = object.key("lengthSetOfPatternString").start_array();
        1142  +
        for item_158 in var_156 {
        1143  +
            {
        1144  +
                array_157.value().string(item_158.as_str());
        1145  +
            }
        1146  +
        }
        1147  +
        array_157.finish();
        1148  +
    }
        1149  +
    Ok(())
        1150  +
}