Server Test

rev. 6fc7cbedb5b89510be0908913ad355c54b288f28 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/.cargo/config.toml

@@ -1,1 +0,2 @@

 [build]
 rustflags = ["--cfg", "aws_sdk_unstable"]
  No newline at end of file
 rustflags = ["--deny", "warnings", "--cfg", "aws_sdk_unstable"]

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

@@ -1257,1257 +1320,1317 @@

↥ Expand context

-1257
+                            )
-1258
+        }
-1259
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<
             crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput,
-1263
+        >
-1264
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-1267
+        }
-1268
+    }
     impl ::std::convert::TryFrom<Builder>
         for crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput
-1271
+    {
         type Error = ConstraintViolation;
-1273
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1276
+        }

-1277
+    }
     /// A builder for [`HttpPrefixHeadersTargetingLengthMapOperationInput`](crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) length_map:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::ConBMap>>,
-1283
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_map(mut self, input: ::std::option::Option<crate::model::ConBMap>) -> Self {
             self.length_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1289
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ConBMap>>,
             >,
         ) -> Self {
             self.length_map = input.map(|v| v.into());

↧ Expand context

             self
-1299
+        }
         /// Consumes the builder and constructs a [`HttpPrefixHeadersTargetingLengthMapOperationInput`](crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput).
         ///
         /// The builder fails to construct a [`HttpPrefixHeadersTargetingLengthMapOperationInput`](crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<
             crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput,
             ConstraintViolation,
         > {
             self.build_enforcing_all_constraints()
-1311
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<
             crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput,
             ConstraintViolation,
         > {

@@ -2604,2601 +2667,2661 @@

↥ Expand context

-2601
+                            )
-2602
+        }
-2603
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<
             crate::input::QueryParamsTargetingLengthMapOperationInput,
-2607
+        >
-2608
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-2611
+        }
-2612
+    }
     impl ::std::convert::TryFrom<Builder>
         for crate::input::QueryParamsTargetingLengthMapOperationInput
-2615
+    {
         type Error = ConstraintViolation;
-2617
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-2620
+        }

-2621
+    }
     /// A builder for [`QueryParamsTargetingLengthMapOperationInput`](crate::input::QueryParamsTargetingLengthMapOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) length_map:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::ConBMap>>,
-2627
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_map(mut self, input: ::std::option::Option<crate::model::ConBMap>) -> Self {
             self.length_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2633
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ConBMap>>,
             >,
         ) -> Self {
             self.length_map = input.map(|v| v.into());

↧ Expand context

             self
-2643
+        }
         /// Consumes the builder and constructs a [`QueryParamsTargetingLengthMapOperationInput`](crate::input::QueryParamsTargetingLengthMapOperationInput).
         ///
         /// The builder fails to construct a [`QueryParamsTargetingLengthMapOperationInput`](crate::input::QueryParamsTargetingLengthMapOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::input::QueryParamsTargetingLengthMapOperationInput, ConstraintViolation>
-2651
+        {
             self.build_enforcing_all_constraints()
-2653
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::QueryParamsTargetingLengthMapOperationInput, ConstraintViolation>
-2657
+        {
             Ok(crate::input::QueryParamsTargetingLengthMapOperationInput {
                 length_map: self
                     .length_map
                     .map(|v| match v {

@@ -2742,2736 +2805,2796 @@

↥ Expand context

-2736
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-2739
+        }
-2740
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::ConstrainedRecursiveShapesOperationInput {
         type Error = ConstraintViolation;
-2743
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-2746
+        }
-2747
+    }
     /// A builder for [`ConstrainedRecursiveShapesOperationInput`](crate::input::ConstrainedRecursiveShapesOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) nested: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::RecursiveShapesInputOutputNested1>,
         >,
         pub(crate) recursive_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<

                 crate::constrained::recursive_list_constrained::RecursiveListConstrained,
             >,
         >,
-2759
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn nested(
             mut self,
             input: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,
         ) -> Self {
             self.nested = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.nested = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2768
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_nested(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::model::RecursiveShapesInputOutputNested1,
                     >,

↧ Expand context

                 >,
             >,
         ) -> Self {
             self.nested = input.map(|v| v.into());
             self
-2782
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn recursive_list(
             mut self,
             input: ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
         ) -> Self {
             self.recursive_list = Some(crate::constrained::MaybeConstrained::Constrained(
                 (input).into(),
             ));
             self
-2792
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_recursive_list(
             mut self,
             input: impl ::std::convert::Into<

@@ -3414,3405 +3477,3466 @@

↥ Expand context

         ) -> Self {
             self.enum_string_label = Some(input.into());
             self
-3408
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string_header_map(
             mut self,
             input: ::std::collections::HashMap<
                 crate::model::LengthString,
                 crate::model::LengthString,
             >,
         ) -> Self {
             self.length_string_header_map = Some(
                 crate::constrained::MaybeConstrained::Constrained((input).into()),
             );
             self
-3421
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string_header_map(
             mut self,

             input: impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained>>,
         ) -> Self {
             self.length_string_header_map = Some(input.into());
             self
-3429
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string_header(
             mut self,
             input: ::std::option::Option<crate::model::LengthString>,
         ) -> Self {
             self.length_string_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_string_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3438
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.length_string_header = input.map(|v| v.into());
             self
-3450
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_integer_header(mut self, input: crate::model::RangeInteger) -> Self {
             self.range_integer_header =
                 Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-3456
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_integer_header(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeInteger>,
             >,
         ) -> Self {
             self.range_integer_header = Some(input.into());
             self
-3466
+        }

@@ -3499,3488 +3719,3694 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_long_header(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeLong>,
             >,
         ) -> Self {
             self.range_long_header = Some(input.into());
             self
-3497
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_byte_header(mut self, input: crate::model::RangeByte) -> Self {
             self.range_byte_header = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-3502
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_byte_header(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeByte>,

             >,
         ) -> Self {
             self.range_byte_header = Some(input.into());
             self
-3512
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string_set_header(
             mut self,
             input: ::std::option::Option<crate::model::SetOfLengthString>,
         ) -> Self {
             self.length_string_set_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_string_set_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3521
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string_set_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>,
                 >,
             >,
         ) -> Self {
             self.length_string_set_header = input.map(|v| v.into());
             self
-3533
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_length_string_header(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::LengthString>>,
         ) -> Self {
             self.list_length_string_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-3544
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_length_string_header(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>>>,
         ) -> Self {
             self.list_length_string_header = input.map(|v| v.into());
             self
-3552
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_list_pattern_string_header(
             mut self,
             input: ::std::option::Option<crate::model::LengthListOfPatternString>,
         ) -> Self {
             self.length_list_pattern_string_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_list_pattern_string_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3561
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_list_pattern_string_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>,
                 >,
             >,
         ) -> Self {
             self.length_list_pattern_string_header = input.map(|v| v.into());
             self
-3573
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_set_pattern_string_header(
             mut self,
             input: ::std::option::Option<crate::model::LengthSetOfPatternString>,
         ) -> Self {
             self.length_set_pattern_string_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_set_pattern_string_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3582
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_set_pattern_string_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>,
                 >,
             >,
         ) -> Self {
             self.length_set_pattern_string_header = input.map(|v| v.into());
             self
-3594
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_byte_set_header(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeByte>,
         ) -> Self {
             self.range_byte_set_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_byte_set_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3603
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_byte_set_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>,
                 >,
             >,
         ) -> Self {
             self.range_byte_set_header = input.map(|v| v.into());
             self
-3615
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_short_set_header(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeShort>,
         ) -> Self {
             self.range_short_set_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_short_set_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3624
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_short_set_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>,
                 >,
             >,
         ) -> Self {
             self.range_short_set_header = input.map(|v| v.into());
             self
-3636
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_integer_set_header(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeInteger>,
         ) -> Self {
             self.range_integer_set_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_integer_set_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3645
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_integer_set_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>,
                 >,
             >,
         ) -> Self {
             self.range_integer_set_header = input.map(|v| v.into());
             self
-3657
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_long_set_header(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeLong>,
         ) -> Self {
             self.range_long_set_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_long_set_header =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3666
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_long_set_header(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.range_long_set_header = input.map(|v| v.into());
             self
-3678
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_byte_list_header(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeByte>>,
         ) -> Self {
             self.range_byte_list_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-3689
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_byte_list_header(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained>>>,
         ) -> Self {

@@ -3755,3730 +3818,3790 @@

↥ Expand context

             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained>>>,
         ) -> Self {
             self.range_integer_list_header = input.map(|v| v.into());
             self
-3735
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_long_list_header(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeLong>>,
         ) -> Self {
             self.range_long_list_header = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-3746
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_long_list_header(
             mut self,

             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained>>>,
         ) -> Self {
             self.range_long_list_header = input.map(|v| v.into());
             self
-3754
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string_query(
             mut self,
             input: ::std::option::Option<crate::model::LengthString>,
         ) -> Self {
             self.length_string_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_string_query = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3762
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.length_string_query = input.map(|v| v.into());
             self
-3774
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_byte_query(mut self, input: crate::model::RangeByte) -> Self {
             self.range_byte_query = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-3779
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_byte_query(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeByte>,
             >,
         ) -> Self {
             self.range_byte_query = Some(input.into());
             self
-3789
+        }
         #[allow(missing_docs)] // documentation missing in model

@@ -3839,3811 +3967,3932 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_integer_query(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeInteger>,
             >,
         ) -> Self {
             self.range_integer_query = Some(input.into());
             self
-3820
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_long_query(mut self, input: crate::model::RangeLong) -> Self {
             self.range_long_query = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-3825
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_long_query(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeLong>,

             >,
         ) -> Self {
             self.range_long_query = Some(input.into());
             self
-3835
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn enum_string_query(
             mut self,
             input: ::std::option::Option<crate::model::EnumString>,
         ) -> Self {
             self.enum_string_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.enum_string_query = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3843
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum_string_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::EnumString>,
                 >,
             >,
         ) -> Self {
             self.enum_string_query = input.map(|v| v.into());
             self
-3855
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string_list_query(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::LengthString>>,
         ) -> Self {
             self.length_string_list_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-3866
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string_list_query(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>>>,
         ) -> Self {
             self.length_string_list_query = input.map(|v| v.into());
             self
-3874
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_list_pattern_string_query(
             mut self,
             input: ::std::option::Option<crate::model::LengthListOfPatternString>,
         ) -> Self {
             self.length_list_pattern_string_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_list_pattern_string_query =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3883
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_list_pattern_string_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>,
                 >,
             >,
         ) -> Self {
             self.length_list_pattern_string_query = input.map(|v| v.into());
             self
-3895
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string_set_query(
             mut self,
             input: ::std::option::Option<crate::model::SetOfLengthString>,
         ) -> Self {
             self.length_string_set_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_string_set_query =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3904
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string_set_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.length_string_set_query = input.map(|v| v.into());
             self
-3916
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_byte_list_query(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeByte>>,
         ) -> Self {
             self.range_byte_list_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-3927
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_byte_list_query(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained>>>,
         ) -> Self {

@@ -4003,3968 +4135,4092 @@

↥ Expand context

             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained>>>,
         ) -> Self {
             self.range_integer_list_query = input.map(|v| v.into());
             self
-3973
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_long_list_query(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeLong>>,
         ) -> Self {
             self.range_long_list_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-3984
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_long_list_query(
             mut self,

             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained>>>,
         ) -> Self {
             self.range_long_list_query = input.map(|v| v.into());
             self
-3992
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_byte_set_query(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeByte>,
         ) -> Self {
             self.range_byte_set_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_byte_set_query =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4001
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_byte_set_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>,
                 >,
             >,
         ) -> Self {
             self.range_byte_set_query = input.map(|v| v.into());
             self
-4013
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_short_set_query(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeShort>,
         ) -> Self {
             self.range_short_set_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_short_set_query =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4022
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_short_set_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>,
                 >,
             >,
         ) -> Self {
             self.range_short_set_query = input.map(|v| v.into());
             self
-4034
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_integer_set_query(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeInteger>,
         ) -> Self {
             self.range_integer_set_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_integer_set_query =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4043
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_integer_set_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>,
                 >,
             >,
         ) -> Self {
             self.range_integer_set_query = input.map(|v| v.into());
             self
-4055
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_long_set_query(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeLong>,
         ) -> Self {
             self.range_long_set_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.range_long_set_query =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4064
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_long_set_query(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.range_long_set_query = input.map(|v| v.into());
             self
-4076
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn enum_string_list_query(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::EnumString>>,
         ) -> Self {
             self.enum_string_list_query = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-4087
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum_string_list_query(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>>>,
         ) -> Self {

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

@@ -5396,5396 +5459,5456 @@

↥ Expand context

-5396
+            }
-5397
+        }
-5398
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::model::RecursiveShapesInputOutputNested2>
-5401
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-5404
+        }
-5405
+    }
     impl ::std::convert::TryFrom<Builder> for crate::model::RecursiveShapesInputOutputNested2 {
         type Error = ConstraintViolation;
-5408
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-5411
+        }
-5412
+    }
     /// A builder for [`RecursiveShapesInputOutputNested2`](crate::model::RecursiveShapesInputOutputNested2).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {

         pub(crate) recursive_member: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::RecursiveShapesInputOutputNested1>,
         >,
-5419
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn recursive_member(
             mut self,
             input: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,
         ) -> Self {
             self.recursive_member = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.recursive_member = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5428
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_recursive_member(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::model::RecursiveShapesInputOutputNested1,
                     >,

↧ Expand context

                 >,
             >,
         ) -> Self {
             self.recursive_member = input.map(|v| v.into());
             self
-5442
+        }
         /// Consumes the builder and constructs a [`RecursiveShapesInputOutputNested2`](crate::model::RecursiveShapesInputOutputNested2).
         ///
         /// The builder fails to construct a [`RecursiveShapesInputOutputNested2`](crate::model::RecursiveShapesInputOutputNested2) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::model::RecursiveShapesInputOutputNested2, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-5451
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::RecursiveShapesInputOutputNested2, ConstraintViolation> {
             Ok(crate::model::RecursiveShapesInputOutputNested2 {
                 recursive_member: self

@@ -6039,6036 +6284,6254 @@

↥ Expand context

         pub(crate) set_of_range_byte: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>>,
         pub(crate) map_of_range_byte: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained>>,
         pub(crate) non_streaming_blob: ::std::option::Option<::aws_smithy_types::Blob>,
         pub(crate) pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::PatternString>>,
         pub(crate) map_of_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained>>,
         pub(crate) list_of_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>>,
         pub(crate) set_of_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SetOfPatternString>>,
         pub(crate) length_length_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthPatternString>>,
         pub(crate) map_of_length_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained>>,
         pub(crate) list_of_length_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>>,
         pub(crate) set_of_length_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SetOfLengthPatternString>>,
         pub(crate) length_list_of_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>>,
         pub(crate) length_set_of_pattern_string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>>,
-6049
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn con_b(mut self, input: crate::model::ConB) -> Self {
             self.con_b = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-6055
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_con_b(
             mut self,
             input: impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ConB>>,
         ) -> Self {
             self.con_b = Some(input.into());
             self
-6063
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn opt_con_b(mut self, input: ::std::option::Option<crate::model::ConB>) -> Self {
             self.opt_con_b = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.opt_con_b = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6068
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_opt_con_b(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ConB>>,
             >,
         ) -> Self {
             self.opt_con_b = input.map(|v| v.into());
             self
-6078
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_string(
             mut self,
             input: ::std::option::Option<crate::model::LengthString>,
         ) -> Self {
             self.length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6086
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthString>,
                 >,
             >,
         ) -> Self {
             self.length_string = input.map(|v| v.into());
             self
-6098
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_length_string(
             mut self,
             input: ::std::option::Option<crate::model::MinLengthString>,
         ) -> Self {
             self.min_length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_length_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6106
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_length_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MinLengthString>,
                 >,
             >,
         ) -> Self {
             self.min_length_string = input.map(|v| v.into());
             self
-6118
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_length_string(
             mut self,
             input: ::std::option::Option<crate::model::MaxLengthString>,
         ) -> Self {
             self.max_length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_length_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6126
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_length_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MaxLengthString>,
                 >,
             >,
         ) -> Self {
             self.max_length_string = input.map(|v| v.into());
             self
-6138
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn fixed_length_string(
             mut self,
             input: ::std::option::Option<crate::model::FixedLengthString>,
         ) -> Self {
             self.fixed_length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.fixed_length_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6146
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_fixed_length_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::FixedLengthString>,
                 >,
             >,
         ) -> Self {
             self.fixed_length_string = input.map(|v| v.into());
             self
-6158
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_blob(
             mut self,
             input: ::std::option::Option<crate::model::LengthBlob>,
         ) -> Self {
             self.length_blob = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_blob = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6166
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_blob(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthBlob>,
                 >,
             >,
         ) -> Self {
             self.length_blob = input.map(|v| v.into());
             self
-6178
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_length_blob(
             mut self,
             input: ::std::option::Option<crate::model::MinLengthBlob>,
         ) -> Self {
             self.min_length_blob = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_length_blob = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6186
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_length_blob(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MinLengthBlob>,
                 >,
             >,
         ) -> Self {
             self.min_length_blob = input.map(|v| v.into());
             self
-6198
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_length_blob(
             mut self,
             input: ::std::option::Option<crate::model::MaxLengthBlob>,
         ) -> Self {
             self.max_length_blob = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_length_blob = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6206
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_length_blob(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MaxLengthBlob>,
                 >,
             >,
         ) -> Self {
             self.max_length_blob = input.map(|v| v.into());
             self
-6218
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn fixed_length_blob(
             mut self,
             input: ::std::option::Option<crate::model::FixedLengthBlob>,
         ) -> Self {
             self.fixed_length_blob = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.fixed_length_blob = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6226
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_fixed_length_blob(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::FixedLengthBlob>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.fixed_length_blob = input.map(|v| v.into());
             self
-6238
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn range_integer(mut self, input: crate::model::RangeInteger) -> Self {
             self.range_integer = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-6243
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_range_integer(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::RangeInteger>,
             >,
         ) -> Self {
             self.range_integer = Some(input.into());
             self
-6253
+        }
         #[allow(missing_docs)] // documentation missing in model

@@ -6510,6480 +6652,6608 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub fn con_b_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<crate::model::ConB>>>,
         ) -> Self {
             self.con_b_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6490
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_con_b_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::constrained::con_b_list_constrained::ConBListConstrained,
                     >,
                 >,

             >,
         ) -> Self {
             self.con_b_list = input.map(|v| v.into());
             self
-6504
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_list(
             mut self,
             input: ::std::option::Option<crate::model::LengthList>,
         ) -> Self {
             self.length_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6512
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthList>,
                 >,
             >,
         ) -> Self {
             self.length_list = input.map(|v| v.into());
             self
-6524
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn sensitive_length_list(
             mut self,
             input: ::std::option::Option<crate::model::SensitiveLengthList>,
         ) -> Self {
             self.sensitive_length_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.sensitive_length_list =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6533
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_sensitive_length_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SensitiveLengthList>,
                 >,
             >,
         ) -> Self {
             self.sensitive_length_list = input.map(|v| v.into());
             self
-6545
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn con_b_set(mut self, input: ::std::option::Option<crate::model::ConBSet>) -> Self {
             self.con_b_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.con_b_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6550
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_con_b_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ConBSet>>,
             >,
         ) -> Self {
             self.con_b_set = input.map(|v| v.into());
             self
-6560
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn con_b_map(mut self, input: ::std::option::Option<crate::model::ConBMap>) -> Self {
             self.con_b_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.con_b_map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6565
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_con_b_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ConBMap>>,
             >,
         ) -> Self {
             self.con_b_map = input.map(|v| v.into());
             self
-6575
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_map(mut self, input: ::std::option::Option<crate::model::LengthMap>) -> Self {
             self.length_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6580
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::LengthMap>>,
             >,
         ) -> Self {
             self.length_map = input.map(|v| v.into());

↧ Expand context

             self
-6590
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_map_of_list_of_list_of_con_b(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<
                     ::std::string::String,
                     ::std::collections::HashMap<
                         ::std::string::String,
                         ::std::vec::Vec<::std::vec::Vec<crate::model::ConB>>,
                     >,
                 >,
             >,
         ) -> Self {
             self.map_of_map_of_list_of_list_of_con_b = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self

@@ -6694,6650 +6868,6810 @@

↥ Expand context

             mut self,
             input: ::std::option::Option<
                 ::std::vec::Vec<::std::option::Option<crate::model::LengthString>>,
             >,
         ) -> Self {
             self.sparse_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6660
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_sparse_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::constrained::sparse_list_constrained::SparseListConstrained,
                     >,
                 >,

             >,
         ) -> Self {
             self.sparse_list = input.map(|v| v.into());
             self
-6674
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn sparse_length_map(
             mut self,
             input: ::std::option::Option<crate::model::SparseLengthMap>,
         ) -> Self {
             self.sparse_length_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.sparse_length_map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6682
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_sparse_length_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SparseLengthMap>,
                 >,
             >,
         ) -> Self {
             self.sparse_length_map = input.map(|v| v.into());
             self
-6694
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn sparse_length_list(
             mut self,
             input: ::std::option::Option<crate::model::SparseLengthList>,
         ) -> Self {
             self.sparse_length_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.sparse_length_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6702
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_sparse_length_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SparseLengthList>,
                 >,
             >,
         ) -> Self {
             self.sparse_length_list = input.map(|v| v.into());
             self
-6714
+        }
         /// A union with constrained members.
         pub fn constrained_union(
             mut self,
             input: ::std::option::Option<crate::model::ConstrainedUnion>,
         ) -> Self {
             self.constrained_union = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.constrained_union = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6722
+        }
         /// A union with constrained members.
         pub(crate) fn set_constrained_union(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::ConstrainedUnion>,
                 >,
             >,
         ) -> Self {
             self.constrained_union = input.map(|v| v.into());
             self
-6734
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn enum_string(
             mut self,
             input: ::std::option::Option<crate::model::EnumString>,
         ) -> Self {
             self.enum_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.enum_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6742
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::EnumString>,
                 >,
             >,
         ) -> Self {
             self.enum_string = input.map(|v| v.into());
             self
-6754
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_length_string(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::LengthString>>,
         ) -> Self {
             self.list_of_length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6765
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_length_string(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>>>,
         ) -> Self {
             self.list_of_length_string = input.map(|v| v.into());
             self
-6773
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_length_string(
             mut self,
             input: ::std::option::Option<crate::model::SetOfLengthString>,
         ) -> Self {
             self.set_of_length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_length_string =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6782
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_length_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.set_of_length_string = input.map(|v| v.into());
             self
-6794
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_length_string(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
             >,
         ) -> Self {
             self.map_of_length_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6807
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map_of_length_string(
             mut self,

@@ -6908,6850 +7220,7148 @@

↥ Expand context

             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained>>>,
         ) -> Self {
             self.map_of_length_blob = input.map(|v| v.into());
             self
-6855
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_range_integer(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeInteger>>,
         ) -> Self {
             self.list_of_range_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6866
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_range_integer(
             mut self,

             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained>>>,
         ) -> Self {
             self.list_of_range_integer = input.map(|v| v.into());
             self
-6874
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_range_integer(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeInteger>,
         ) -> Self {
             self.set_of_range_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_range_integer =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6883
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_range_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>,
                 >,
             >,
         ) -> Self {
             self.set_of_range_integer = input.map(|v| v.into());
             self
-6895
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_range_integer(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<::std::string::String, crate::model::RangeInteger>,
             >,
         ) -> Self {
             self.map_of_range_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6908
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map_of_range_integer(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained>>>,
         ) -> Self {
             self.map_of_range_integer = input.map(|v| v.into());
             self
-6916
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_range_short(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeShort>>,
         ) -> Self {
             self.list_of_range_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6927
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_range_short(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained>>>,
         ) -> Self {
             self.list_of_range_short = input.map(|v| v.into());
             self
-6935
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_range_short(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeShort>,
         ) -> Self {
             self.set_of_range_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_range_short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6943
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_range_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>,
                 >,
             >,
         ) -> Self {
             self.set_of_range_short = input.map(|v| v.into());
             self
-6955
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_range_short(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<::std::string::String, crate::model::RangeShort>,
             >,
         ) -> Self {
             self.map_of_range_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6968
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map_of_range_short(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained>>>,
         ) -> Self {
             self.map_of_range_short = input.map(|v| v.into());
             self
-6976
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_range_long(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeLong>>,
         ) -> Self {
             self.list_of_range_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6987
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_range_long(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained>>>,
         ) -> Self {
             self.list_of_range_long = input.map(|v| v.into());
             self
-6995
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_range_long(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeLong>,
         ) -> Self {
             self.set_of_range_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_range_long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7003
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_range_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>,
                 >,
             >,
         ) -> Self {
             self.set_of_range_long = input.map(|v| v.into());
             self
-7015
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_range_long(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<::std::string::String, crate::model::RangeLong>,
             >,
         ) -> Self {
             self.map_of_range_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7028
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map_of_range_long(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained>>>,
         ) -> Self {
             self.map_of_range_long = input.map(|v| v.into());
             self
-7036
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_range_byte(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::RangeByte>>,
         ) -> Self {
             self.list_of_range_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7047
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_range_byte(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained>>>,
         ) -> Self {
             self.list_of_range_byte = input.map(|v| v.into());
             self
-7055
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_range_byte(
             mut self,
             input: ::std::option::Option<crate::model::SetOfRangeByte>,
         ) -> Self {
             self.set_of_range_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_range_byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7063
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_range_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>,
                 >,
             >,
         ) -> Self {
             self.set_of_range_byte = input.map(|v| v.into());
             self
-7075
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_range_byte(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<::std::string::String, crate::model::RangeByte>,
             >,
         ) -> Self {
             self.map_of_range_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7088
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map_of_range_byte(
             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained>>>,
         ) -> Self {
             self.map_of_range_byte = input.map(|v| v.into());
             self
-7096
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn non_streaming_blob(
             mut self,
             input: ::std::option::Option<::aws_smithy_types::Blob>,
         ) -> Self {
             self.non_streaming_blob = input;
             self
-7104
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_non_streaming_blob(
             mut self,
             input: Option<impl ::std::convert::Into<::aws_smithy_types::Blob>>,
         ) -> Self {
             self.non_streaming_blob = input.map(|v| v.into());
             self
-7112
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn pattern_string(
             mut self,
             input: ::std::option::Option<crate::model::PatternString>,
         ) -> Self {
             self.pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.pattern_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7120
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_pattern_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::PatternString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.pattern_string = input.map(|v| v.into());
             self
-7132
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_pattern_string(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<
                     crate::model::PatternString,
                     crate::model::PatternString,
                 >,
             >,
         ) -> Self {
             self.map_of_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7148
+        }

@@ -7223,7151 +7309,7233 @@

↥ Expand context

             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained>>>,
         ) -> Self {
             self.map_of_pattern_string = input.map(|v| v.into());
             self
-7156
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_pattern_string(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::PatternString>>,
         ) -> Self {
             self.list_of_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7167
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_pattern_string(
             mut self,

             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>>>,
         ) -> Self {
             self.list_of_pattern_string = input.map(|v| v.into());
             self
-7175
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_pattern_string(
             mut self,
             input: ::std::option::Option<crate::model::SetOfPatternString>,
         ) -> Self {
             self.set_of_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_pattern_string =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7184
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_pattern_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfPatternString>,
                 >,
             >,
         ) -> Self {
             self.set_of_pattern_string = input.map(|v| v.into());
             self
-7196
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_length_pattern_string(
             mut self,
             input: ::std::option::Option<crate::model::LengthPatternString>,
         ) -> Self {
             self.length_length_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_length_pattern_string =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7205
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_length_pattern_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthPatternString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.length_length_pattern_string = input.map(|v| v.into());
             self
-7217
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map_of_length_pattern_string(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<
                     crate::model::LengthPatternString,
                     crate::model::LengthPatternString,
                 >,
             >,
         ) -> Self {
             self.map_of_length_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7233
+        }

@@ -7312,7236 +7421,7339 @@

↥ Expand context

             mut self,
             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained>>>,
         ) -> Self {
             self.map_of_length_pattern_string = input.map(|v| v.into());
             self
-7241
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_of_length_pattern_string(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::LengthPatternString>>,
         ) -> Self {
             self.list_of_length_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-7252
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_of_length_pattern_string(
             mut self,

             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>>>,
         ) -> Self {
             self.list_of_length_pattern_string = input.map(|v| v.into());
             self
-7260
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn set_of_length_pattern_string(
             mut self,
             input: ::std::option::Option<crate::model::SetOfLengthPatternString>,
         ) -> Self {
             self.set_of_length_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.set_of_length_pattern_string =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7269
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_set_of_length_pattern_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SetOfLengthPatternString>,
                 >,
             >,
         ) -> Self {
             self.set_of_length_pattern_string = input.map(|v| v.into());
             self
-7281
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_list_of_pattern_string(
             mut self,
             input: ::std::option::Option<crate::model::LengthListOfPatternString>,
         ) -> Self {
             self.length_list_of_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_list_of_pattern_string =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7290
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_list_of_pattern_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>,
                 >,
             >,
         ) -> Self {
             self.length_list_of_pattern_string = input.map(|v| v.into());
             self
-7302
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn length_set_of_pattern_string(
             mut self,
             input: ::std::option::Option<crate::model::LengthSetOfPatternString>,
         ) -> Self {
             self.length_set_of_pattern_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.length_set_of_pattern_string =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7311
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_length_set_of_pattern_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.length_set_of_pattern_string = input.map(|v| v.into());
             self
-7323
+        }
         /// Consumes the builder and constructs a [`ConA`](crate::model::ConA).
         ///
         /// The builder fails to construct a [`ConA`](crate::model::ConA) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::model::ConA, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-7331
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::ConA, ConstraintViolation> {
             Ok(
                 crate::model::ConA {
                     con_b: self.con_b
                         .map(|v| match v {
                                             crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

tmp-codegen-diff/codegen-server-test/ebs/rust-server-codegen/src/input.rs

@@ -480,480 +573,567 @@

↥ Expand context

         pub(crate) timeout:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Timeout>>,
         pub(crate) client_token: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::IdempotencyToken>,
         >,
         pub(crate) volume_size:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::VolumeSize>>,
         pub(crate) tags: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::tags_constrained::TagsConstrained,
             >,
         >,
         pub(crate) encrypted: ::std::option::Option<bool>,
         pub(crate) kms_key_arn:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::KmsKeyArn>>,
         pub(crate) parent_snapshot_id:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SnapshotId>>,
         pub(crate) description:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Description>>,
-499
+    }

     impl Builder {
         /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>
         /// <ul>
         /// <li>
         /// <p>No blocks are written to the snapshot.</p></li>
         /// <li>
         /// <p>The snapshot is not completed after writing the last block of data.</p></li>
         /// </ul>
         /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>
         pub fn timeout(mut self, input: ::std::option::Option<crate::model::Timeout>) -> Self {
             self.timeout = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.timeout = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-512
+        }
         /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>
         /// <ul>
         /// <li>
         /// <p>No blocks are written to the snapshot.</p></li>
         /// <li>
         /// <p>The snapshot is not completed after writing the last block of data.</p></li>
         /// </ul>
         /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>
         pub(crate) fn set_timeout(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Timeout>>,
             >,
         ) -> Self {
             self.timeout = input.map(|v| v.into());
             self
-529
+        }
         /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully. The subsequent retries with the same client token return the result from the original successful request and they have no additional effect.</p>
         /// <p>If you do not specify a client token, one is automatically generated by the AWS SDK.</p>
         /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-direct-api-idempotency.html"> Idempotency for StartSnapshot API</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
         pub fn client_token(
             mut self,
             input: ::std::option::Option<crate::model::IdempotencyToken>,
         ) -> Self {
             self.client_token = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.client_token = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-539
+        }
         /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully. The subsequent retries with the same client token return the result from the original successful request and they have no additional effect.</p>
         /// <p>If you do not specify a client token, one is automatically generated by the AWS SDK.</p>
         /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-direct-api-idempotency.html"> Idempotency for StartSnapshot API</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
         pub(crate) fn set_client_token(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::IdempotencyToken>,

↧ Expand context

                 >,
             >,
         ) -> Self {
             self.client_token = input.map(|v| v.into());
             self
-553
+        }
         /// <p>The size of the volume, in GiB. The maximum size is <code>16384</code> GiB (16 TiB).</p>
         pub fn volume_size(mut self, input: crate::model::VolumeSize) -> Self {
             self.volume_size = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-558
+        }
         /// <p>The size of the volume, in GiB. The maximum size is <code>16384</code> GiB (16 TiB).</p>
         pub(crate) fn set_volume_size(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::VolumeSize>,
             >,
         ) -> Self {
             self.volume_size = Some(input.into());
             self

@@ -598,592 +709,694 @@

↥ Expand context

             self
-593
+        }
         /// <p>Indicates whether to encrypt the snapshot. To create an encrypted snapshot, specify <code>true</code>. To create an unencrypted snapshot, omit this parameter.</p>
         /// <p>If you specify a value for <b>ParentSnapshotId</b>, omit this parameter.</p>
         /// <p>If you specify <code>true</code>, the snapshot is encrypted using the CMK specified using the <b>KmsKeyArn</b> parameter. If no value is specified for <b>KmsKeyArn</b>, the default CMK for your account is used. If no default CMK has been specified for your account, the AWS managed CMK is used. To set a default CMK for your account, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyEbsDefaultKmsKeyId.html"> ModifyEbsDefaultKmsKeyId</a>.</p>
         /// <p>If your account is enabled for encryption by default, you cannot set this parameter to <code>false</code>. In this case, you can omit this parameter.</p>
         /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-encryption"> Using encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
         pub fn encrypted(mut self, input: ::std::option::Option<bool>) -> Self {
             self.encrypted = input;
             self
-602
+        }
         /// <p>Indicates whether to encrypt the snapshot. To create an encrypted snapshot, specify <code>true</code>. To create an unencrypted snapshot, omit this parameter.</p>
         /// <p>If you specify a value for <b>ParentSnapshotId</b>, omit this parameter.</p>
         /// <p>If you specify <code>true</code>, the snapshot is encrypted using the CMK specified using the <b>KmsKeyArn</b> parameter. If no value is specified for <b>KmsKeyArn</b>, the default CMK for your account is used. If no default CMK has been specified for your account, the AWS managed CMK is used. To set a default CMK for your account, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyEbsDefaultKmsKeyId.html"> ModifyEbsDefaultKmsKeyId</a>.</p>
         /// <p>If your account is enabled for encryption by default, you cannot set this parameter to <code>false</code>. In this case, you can omit this parameter.</p>
         /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-encryption"> Using encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
         pub(crate) fn set_encrypted(
             mut self,
             input: Option<impl ::std::convert::Into<bool>>,
         ) -> Self {

             self.encrypted = input.map(|v| v.into());
             self
-614
+        }
         /// <p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) customer master key (CMK) to be used to encrypt the snapshot. If you do not specify a CMK, the default AWS managed CMK is used.</p>
         /// <p>If you specify a <b>ParentSnapshotId</b>, omit this parameter; the snapshot will be encrypted using the same CMK that was used to encrypt the parent snapshot.</p>
         /// <p>If <b>Encrypted</b> is set to <code>true</code>, you must specify a CMK ARN.</p>
         pub fn kms_key_arn(
             mut self,
             input: ::std::option::Option<crate::model::KmsKeyArn>,
         ) -> Self {
             self.kms_key_arn = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.kms_key_arn = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-624
+        }
         /// <p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) customer master key (CMK) to be used to encrypt the snapshot. If you do not specify a CMK, the default AWS managed CMK is used.</p>
         /// <p>If you specify a <b>ParentSnapshotId</b>, omit this parameter; the snapshot will be encrypted using the same CMK that was used to encrypt the parent snapshot.</p>
         /// <p>If <b>Encrypted</b> is set to <code>true</code>, you must specify a CMK ARN.</p>
         pub(crate) fn set_kms_key_arn(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::KmsKeyArn>>,
             >,
         ) -> Self {
             self.kms_key_arn = input.map(|v| v.into());
             self
-636
+        }
         /// <p>The ID of the parent snapshot. If there is no parent snapshot, or if you are creating the first snapshot for an on-premises volume, omit this parameter.</p>
         /// <p>If your account is enabled for encryption by default, you cannot use an unencrypted snapshot as a parent snapshot. You must first create an encrypted copy of the parent snapshot using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopySnapshot.html">CopySnapshot</a>.</p>
         pub fn parent_snapshot_id(
             mut self,
             input: ::std::option::Option<crate::model::SnapshotId>,
         ) -> Self {
             self.parent_snapshot_id = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.parent_snapshot_id = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-645
+        }
         /// <p>The ID of the parent snapshot. If there is no parent snapshot, or if you are creating the first snapshot for an on-premises volume, omit this parameter.</p>
         /// <p>If your account is enabled for encryption by default, you cannot use an unencrypted snapshot as a parent snapshot. You must first create an encrypted copy of the parent snapshot using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopySnapshot.html">CopySnapshot</a>.</p>
         pub(crate) fn set_parent_snapshot_id(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SnapshotId>,
                 >,
             >,
         ) -> Self {
             self.parent_snapshot_id = input.map(|v| v.into());
             self
-658
+        }
         /// <p>A description for the snapshot.</p>
         pub fn description(
             mut self,
             input: ::std::option::Option<crate::model::Description>,
         ) -> Self {
             self.description = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.description = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-666
+        }
         /// <p>A description for the snapshot.</p>
         pub(crate) fn set_description(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::Description>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.description = input.map(|v| v.into());
             self
-678
+        }
         /// Consumes the builder and constructs a [`StartSnapshotInput`](crate::input::StartSnapshotInput).
         ///
         /// The builder fails to construct a [`StartSnapshotInput`](crate::input::StartSnapshotInput) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::input::StartSnapshotInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-686
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::StartSnapshotInput, ConstraintViolation> {
             Ok(crate::input::StartSnapshotInput {
                 timeout: self
                     .timeout
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

@@ -942,927 +1005,987 @@

↥ Expand context

             self.block_index = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-929
+        }
         /// <p>The block index of the block in which to write the data. A block index is a logical index in units of <code>512</code> KiB blocks. To identify the block index, divide the logical offset of the data in the logical volume by the block size (logical offset of data/<code>524288</code>). The logical offset of the data must be <code>512</code> KiB aligned.</p>
         pub(crate) fn set_block_index(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::BlockIndex>,
             >,
         ) -> Self {
             self.block_index = Some(input.into());
             self
-939
+        }
         /// <p>A Base64-encoded SHA256 checksum of the data. Only SHA256 checksums are supported.</p>
         pub fn checksum(mut self, input: crate::model::Checksum) -> Self {
             self.checksum = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-944
+        }
         /// <p>A Base64-encoded SHA256 checksum of the data. Only SHA256 checksums are supported.</p>
         pub(crate) fn set_checksum(

             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::Checksum>,
             >,
         ) -> Self {
             self.checksum = Some(input.into());
             self
-954
+        }
         /// <p>The progress of the write process, as a percentage.</p>
         pub fn progress(mut self, input: ::std::option::Option<crate::model::Progress>) -> Self {
             self.progress = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.progress = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-959
+        }
         /// <p>The progress of the write process, as a percentage.</p>
         pub(crate) fn set_progress(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Progress>>,
             >,
         ) -> Self {
             self.progress = input.map(|v| v.into());

↧ Expand context

             self
-969
+        }
         /// <p>The data to write to the block.</p>
         /// <p>The block data is not signed as part of the Signature Version 4 signing process. As a result, you must generate and provide a Base64-encoded SHA256 checksum for the block data using the <b>x-amz-Checksum</b> header. Also, you must specify the checksum algorithm using the <b>x-amz-Checksum-Algorithm</b> header. The checksum that you provide is part of the Signature Version 4 signing process. It is validated against a checksum generated by Amazon EBS to ensure the validity and authenticity of the data. If the checksums do not correspond, the request fails. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-checksums"> Using checksums with the EBS direct APIs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
         pub fn block_data(mut self, input: ::aws_smithy_types::byte_stream::ByteStream) -> Self {
             self.block_data = Some(input);
             self
-975
+        }
         /// <p>The data to write to the block.</p>
         /// <p>The block data is not signed as part of the Signature Version 4 signing process. As a result, you must generate and provide a Base64-encoded SHA256 checksum for the block data using the <b>x-amz-Checksum</b> header. Also, you must specify the checksum algorithm using the <b>x-amz-Checksum-Algorithm</b> header. The checksum that you provide is part of the Signature Version 4 signing process. It is validated against a checksum generated by Amazon EBS to ensure the validity and authenticity of the data. If the checksums do not correspond, the request fails. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-checksums"> Using checksums with the EBS direct APIs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
         pub(crate) fn set_block_data(
             mut self,
             input: impl ::std::convert::Into<::aws_smithy_types::byte_stream::ByteStream>,
         ) -> Self {
             self.block_data = Some(input.into());
             self
-984
+        }
         /// <p>The size of the data to write to the block, in bytes. Currently, the only supported size is <code>524288</code>.</p>
         /// <p>Valid values: <code>524288</code></p>
         pub fn data_length(mut self, input: i32) -> Self {

@@ -1183,1165 +1289,1263 @@

↥ Expand context

-1165
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-1168
+        }
-1169
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::ListSnapshotBlocksInput {
         type Error = ConstraintViolation;
-1172
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1175
+        }
-1176
+    }
     /// A builder for [`ListSnapshotBlocksInput`](crate::input::ListSnapshotBlocksInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) max_results:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MaxResults>>,
         pub(crate) starting_block_index:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::BlockIndex>>,
         pub(crate) next_token:

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::PageToken>>,
         pub(crate) snapshot_id:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SnapshotId>>,
-1188
+    }
     impl Builder {
         /// <p>The number of results to return.</p>
         pub fn max_results(
             mut self,
             input: ::std::option::Option<crate::model::MaxResults>,
         ) -> Self {
             self.max_results = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_results = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1197
+        }
         /// <p>The number of results to return.</p>
         pub(crate) fn set_max_results(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MaxResults>,
                 >,
             >,
         ) -> Self {
             self.max_results = input.map(|v| v.into());
             self
-1209
+        }
         /// <p>The block index from which the list should start. The list in the response will start from this block index or the next valid block index in the snapshot.</p>
         pub fn starting_block_index(
             mut self,
             input: ::std::option::Option<crate::model::BlockIndex>,
         ) -> Self {
             self.starting_block_index = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.starting_block_index =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1218
+        }
         /// <p>The block index from which the list should start. The list in the response will start from this block index or the next valid block index in the snapshot.</p>
         pub(crate) fn set_starting_block_index(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::BlockIndex>,
                 >,
             >,
         ) -> Self {
             self.starting_block_index = input.map(|v| v.into());
             self
-1230
+        }
         /// <p>The token to request the next page of results.</p>
         pub fn next_token(mut self, input: ::std::option::Option<crate::model::PageToken>) -> Self {
             self.next_token = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.next_token = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1235
+        }
         /// <p>The token to request the next page of results.</p>
         pub(crate) fn set_next_token(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::PageToken>>,
             >,
         ) -> Self {
             self.next_token = input.map(|v| v.into());

↧ Expand context

             self
-1245
+        }
         /// <p>The ID of the snapshot from which to get block indexes and block tokens.</p>
         pub fn snapshot_id(mut self, input: crate::model::SnapshotId) -> Self {
             self.snapshot_id = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-1250
+        }
         /// <p>The ID of the snapshot from which to get block indexes and block tokens.</p>
         pub(crate) fn set_snapshot_id(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::SnapshotId>,
             >,
         ) -> Self {
             self.snapshot_id = Some(input.into());
             self
-1260
+        }
         /// Consumes the builder and constructs a [`ListSnapshotBlocksInput`](crate::input::ListSnapshotBlocksInput).
         ///
         /// The builder fails to construct a [`ListSnapshotBlocksInput`](crate::input::ListSnapshotBlocksInput) if a [`ConstraintViolation`] occurs.

@@ -1438,1412 +1568,1531 @@

↥ Expand context

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::BlockIndex>>,
-1413
+    }
     impl Builder {
         /// <p>The ID of the second snapshot to use for the comparison.</p><important>
         /// <p>The <code>SecondSnapshotId</code> parameter must be specified with a <code>FirstSnapshotID</code> parameter; otherwise, an error occurs.</p>
         /// </important>
         pub fn second_snapshot_id(mut self, input: crate::model::SnapshotId) -> Self {
             self.second_snapshot_id =
                 Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-1422
+        }
         /// <p>The ID of the second snapshot to use for the comparison.</p><important>
         /// <p>The <code>SecondSnapshotId</code> parameter must be specified with a <code>FirstSnapshotID</code> parameter; otherwise, an error occurs.</p>
         /// </important>
         pub(crate) fn set_second_snapshot_id(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::SnapshotId>,
             >,
         ) -> Self {

             self.second_snapshot_id = Some(input.into());
             self
-1434
+        }
         /// <p>The ID of the first snapshot to use for the comparison.</p><important>
         /// <p>The <code>FirstSnapshotID</code> parameter must be specified with a <code>SecondSnapshotId</code> parameter; otherwise, an error occurs.</p>
         /// </important>
         pub fn first_snapshot_id(
             mut self,
             input: ::std::option::Option<crate::model::SnapshotId>,
         ) -> Self {
             self.first_snapshot_id = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.first_snapshot_id = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1444
+        }
         /// <p>The ID of the first snapshot to use for the comparison.</p><important>
         /// <p>The <code>FirstSnapshotID</code> parameter must be specified with a <code>SecondSnapshotId</code> parameter; otherwise, an error occurs.</p>
         /// </important>
         pub(crate) fn set_first_snapshot_id(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::SnapshotId>,
                 >,
             >,
         ) -> Self {
             self.first_snapshot_id = input.map(|v| v.into());
             self
-1458
+        }
         /// <p>The token to request the next page of results.</p>
         pub fn next_token(mut self, input: ::std::option::Option<crate::model::PageToken>) -> Self {
             self.next_token = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.next_token = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1463
+        }
         /// <p>The token to request the next page of results.</p>
         pub(crate) fn set_next_token(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::PageToken>>,
             >,
         ) -> Self {
             self.next_token = input.map(|v| v.into());
             self
-1473
+        }
         /// <p>The number of results to return.</p>
         pub fn max_results(
             mut self,
             input: ::std::option::Option<crate::model::MaxResults>,
         ) -> Self {
             self.max_results = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_results = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1481
+        }
         /// <p>The number of results to return.</p>
         pub(crate) fn set_max_results(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MaxResults>,
                 >,
             >,
         ) -> Self {
             self.max_results = input.map(|v| v.into());
             self
-1493
+        }
         /// <p>The block index from which the comparison should start.</p>
         /// <p>The list in the response will start from this block index or the next valid block index in the snapshots.</p>
         pub fn starting_block_index(
             mut self,
             input: ::std::option::Option<crate::model::BlockIndex>,
         ) -> Self {
             self.starting_block_index = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.starting_block_index =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1503
+        }
         /// <p>The block index from which the comparison should start.</p>
         /// <p>The list in the response will start from this block index or the next valid block index in the snapshots.</p>
         pub(crate) fn set_starting_block_index(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::BlockIndex>,
                 >,

↧ Expand context

             >,
         ) -> Self {
             self.starting_block_index = input.map(|v| v.into());
             self
-1516
+        }
         /// Consumes the builder and constructs a [`ListChangedBlocksInput`](crate::input::ListChangedBlocksInput).
         ///
         /// The builder fails to construct a [`ListChangedBlocksInput`](crate::input::ListChangedBlocksInput) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::input::ListChangedBlocksInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1524
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::ListChangedBlocksInput, ConstraintViolation> {
             Ok(crate::input::ListChangedBlocksInput {
                 second_snapshot_id: self
                     .second_snapshot_id
                     .map(|v| match v {

@@ -1914,1877 +2036,1991 @@

↥ Expand context

         pub(crate) checksum_algorithm: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::ChecksumAlgorithm>,
         >,
         pub(crate) snapshot_id:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SnapshotId>>,
         pub(crate) checksum:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Checksum>>,
-1884
+    }
     impl Builder {
         /// <p>The number of blocks that were written to the snapshot.</p>
         pub fn changed_blocks_count(mut self, input: crate::model::ChangedBlocksCount) -> Self {
             self.changed_blocks_count =
                 Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-1891
+        }
         /// <p>The number of blocks that were written to the snapshot.</p>
         pub(crate) fn set_changed_blocks_count(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::ChangedBlocksCount>,

             >,
         ) -> Self {
             self.changed_blocks_count = Some(input.into());
             self
-1901
+        }
         /// <p>The aggregation method used to generate the checksum. Currently, the only supported aggregation method is <code>LINEAR</code>.</p>
         pub fn checksum_aggregation_method(
             mut self,
             input: ::std::option::Option<crate::model::ChecksumAggregationMethod>,
         ) -> Self {
             self.checksum_aggregation_method = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.checksum_aggregation_method =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1910
+        }
         /// <p>The aggregation method used to generate the checksum. Currently, the only supported aggregation method is <code>LINEAR</code>.</p>
         pub(crate) fn set_checksum_aggregation_method(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::ChecksumAggregationMethod>,
                 >,
             >,
         ) -> Self {
             self.checksum_aggregation_method = input.map(|v| v.into());
             self
-1922
+        }
         /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>
         pub fn checksum_algorithm(
             mut self,
             input: ::std::option::Option<crate::model::ChecksumAlgorithm>,
         ) -> Self {
             self.checksum_algorithm = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.checksum_algorithm = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1930
+        }
         /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>
         pub(crate) fn set_checksum_algorithm(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::ChecksumAlgorithm>,
                 >,
             >,
         ) -> Self {
             self.checksum_algorithm = input.map(|v| v.into());
             self
-1942
+        }
         /// <p>The ID of the snapshot.</p>
         pub fn snapshot_id(mut self, input: crate::model::SnapshotId) -> Self {
             self.snapshot_id = Some(crate::constrained::MaybeConstrained::Constrained(input));
             self
-1947
+        }
         /// <p>The ID of the snapshot.</p>
         pub(crate) fn set_snapshot_id(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::SnapshotId>,
             >,
         ) -> Self {
             self.snapshot_id = Some(input.into());
             self
-1957
+        }
         /// <p>An aggregated Base-64 SHA256 checksum based on the checksums of each written block.</p>
         /// <p>To generate the aggregated checksum using the linear aggregation method, arrange the checksums for each written block in ascending order of their block index, concatenate them to form a single string, and then generate the checksum on the entire string using the SHA256 algorithm.</p>
         pub fn checksum(mut self, input: ::std::option::Option<crate::model::Checksum>) -> Self {
             self.checksum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.checksum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1963
+        }
         /// <p>An aggregated Base-64 SHA256 checksum based on the checksums of each written block.</p>
         /// <p>To generate the aggregated checksum using the linear aggregation method, arrange the checksums for each written block in ascending order of their block index, concatenate them to form a single string, and then generate the checksum on the entire string using the SHA256 algorithm.</p>
         pub(crate) fn set_checksum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Checksum>>,
             >,
         ) -> Self {

↧ Expand context

             self.checksum = input.map(|v| v.into());
             self
-1974
+        }
         /// Consumes the builder and constructs a [`CompleteSnapshotInput`](crate::input::CompleteSnapshotInput).
         ///
         /// The builder fails to construct a [`CompleteSnapshotInput`](crate::input::CompleteSnapshotInput) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::input::CompleteSnapshotInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1982
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::CompleteSnapshotInput, ConstraintViolation> {
             Ok(crate::input::CompleteSnapshotInput {
                 changed_blocks_count: self
                     .changed_blocks_count
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

tmp-codegen-diff/codegen-server-test/ebs/rust-server-codegen/src/model.rs

@@ -2757,2757 +2838,2832 @@

↥ Expand context

-2757
+                }
                 ConstraintViolation::Value(inner) => {
                     inner.as_validation_exception_field(path + "/Value")
-2760
+                }
-2761
+            }
-2762
+        }
-2763
+    }
     impl ::std::convert::From<Builder> for crate::constrained::MaybeConstrained<crate::model::Tag> {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-2767
+        }
-2768
+    }
     impl ::std::convert::TryFrom<Builder> for crate::model::Tag {
         type Error = ConstraintViolation;
-2771
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-2774
+        }
-2775
+    }
     /// A builder for [`Tag`](crate::model::Tag).

     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) key:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::TagKey>>,
         pub(crate) value:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::TagValue>>,
-2783
+    }
     impl Builder {
         /// <p>The key of the tag.</p>
         pub fn key(mut self, input: ::std::option::Option<crate::model::TagKey>) -> Self {
             self.key = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.key = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2789
+        }
         /// <p>The key of the tag.</p>
         pub(crate) fn set_key(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::TagKey>>,
             >,
         ) -> Self {
             self.key = input.map(|v| v.into());
             self
-2799
+        }
         /// <p>The value of the tag.</p>
         pub fn value(mut self, input: ::std::option::Option<crate::model::TagValue>) -> Self {
             self.value = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.value = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2804
+        }
         /// <p>The value of the tag.</p>
         pub(crate) fn set_value(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::TagValue>>,
             >,
         ) -> Self {
             self.value = input.map(|v| v.into());

↧ Expand context

             self
-2814
+        }
         /// Consumes the builder and constructs a [`Tag`](crate::model::Tag).
         ///
         /// The builder fails to construct a [`Tag`](crate::model::Tag) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::model::Tag, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-2822
+        }
         fn build_enforcing_all_constraints(self) -> Result<crate::model::Tag, ConstraintViolation> {
             Ok(crate::model::Tag {
                 key: self
                     .key
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Key))
                     .transpose()?,

tmp-codegen-diff/codegen-server-test/json_rpc10/rust-server-codegen/src/input.rs

@@ -499,499 +562,559 @@

↥ Expand context

-499
+                            )
-500
+        }
-501
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::OperationWithDefaultsInput>
-504
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-507
+        }
-508
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::OperationWithDefaultsInput {
         type Error = ConstraintViolation;
-511
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-514
+        }
-515
+    }
     /// A builder for [`OperationWithDefaultsInput`](crate::input::OperationWithDefaultsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {

         pub(crate) defaults:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Defaults>>,
         pub(crate) client_optional_defaults:
             ::std::option::Option<crate::model::ClientOptionalDefaults>,
         pub(crate) top_level_default: ::std::option::Option<::std::string::String>,
         pub(crate) other_top_level_default: ::std::option::Option<i32>,
-525
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn defaults(mut self, input: ::std::option::Option<crate::model::Defaults>) -> Self {
             self.defaults = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.defaults = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-531
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_defaults(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Defaults>>,
             >,
         ) -> Self {
             self.defaults = input.map(|v| v.into());

↧ Expand context

             self
-541
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn client_optional_defaults(
             mut self,
             input: ::std::option::Option<crate::model::ClientOptionalDefaults>,
         ) -> Self {
             self.client_optional_defaults = input;
             self
-549
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_client_optional_defaults(
             mut self,
             input: Option<impl ::std::convert::Into<crate::model::ClientOptionalDefaults>>,
         ) -> Self {
             self.client_optional_defaults = input.map(|v| v.into());
             self
-557
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn top_level_default(mut self, input: ::std::string::String) -> Self {

@@ -897,894 +960,954 @@

↥ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-898
+                            )
-899
+        }
-900
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonUnionsInput>
-903
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-906
+        }
-907
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonUnionsInput {
         type Error = ConstraintViolation;
-910
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-913
+        }

-914
+    }
     /// A builder for [`JsonUnionsInput`](crate::input::JsonUnionsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) contents:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MyUnion>>,
-920
+    }
     impl Builder {
         /// A union with a representative set of types for members.
         pub fn contents(mut self, input: ::std::option::Option<crate::model::MyUnion>) -> Self {
             self.contents = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.contents = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-926
+        }
         /// A union with a representative set of types for members.
         pub(crate) fn set_contents(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MyUnion>>,
             >,
         ) -> Self {
             self.contents = input.map(|v| v.into());

↧ Expand context

             self
-936
+        }
         /// Consumes the builder and constructs a [`JsonUnionsInput`](crate::input::JsonUnionsInput).
         ///
         /// The builder fails to construct a [`JsonUnionsInput`](crate::input::JsonUnionsInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::JsonUnionsInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-943
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::JsonUnionsInput, ConstraintViolation> {
             Ok(crate::input::JsonUnionsInput {
                 contents: self
                     .contents
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Contents))

tmp-codegen-diff/codegen-server-test/json_rpc10/rust-server-codegen/src/model.rs

@@ -1039,1039 +1106,1100 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_map(
             mut self,
             input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         ) -> Self {
             self.dialog_map = Some(input);
             self
-1046
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_dialog_map(
             mut self,
             input: impl ::std::convert::Into<
                 ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
             >,
         ) -> Self {
             self.dialog_map = Some(input.into());
             self
-1056
+        }
         /// Consumes the builder and constructs a [`TopLevel`](crate::model::TopLevel).
         ///

         /// The builder fails to construct a [`TopLevel`](crate::model::TopLevel) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::TopLevel, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1063
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::TopLevel, ConstraintViolation> {
             Ok(crate::model::TopLevel {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-1072
+        }
-1073
+    }
-1074
+}
 /// See [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
 pub mod client_optional_defaults {
-1077
     impl ::std::convert::From<Builder> for crate::model::ClientOptionalDefaults {
         fn from(builder: Builder) -> Self {
             builder.build()

↧ Expand context

-1081
+        }
-1082
+    }
     /// A builder for [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) member: ::std::option::Option<i32>,
-1087
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn member(mut self, input: i32) -> Self {
             self.member = Some(input);
             self
-1093
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_member(mut self, input: impl ::std::convert::Into<i32>) -> Self {
             self.member = Some(input.into());
             self
-1098
+        }
         /// Consumes the builder and constructs a [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
         pub fn build(self) -> crate::model::ClientOptionalDefaults {

@@ -1519,1513 +1616,1604 @@

↥ Expand context

         pub(crate) fn set_zero_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
             self.zero_float = Some(input.into());
             self
-1516
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-1521
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_zero_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
             self.zero_double = Some(input.into());
             self
-1526
+        }
         /// Consumes the builder and constructs a [`Defaults`](crate::model::Defaults).
         ///
         /// The builder fails to construct a [`Defaults`](crate::model::Defaults) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::Defaults, ConstraintViolation> {
             self.build_enforcing_all_constraints()

-1533
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::Defaults, ConstraintViolation> {
             Ok(crate::model::Defaults {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Object(::std::collections::HashMap::new()),
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::String(::std::string::String::from("hi")),
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true)),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc"),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 default_double: self.default_double.unwrap_or(1.0f64),
                 default_map: self.default_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 default_map: self.default_map.unwrap_or_default(),
                 default_enum: self
                     .default_enum
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::DefaultEnum))
                     .transpose()?
                     .unwrap_or(
                         "FOO"

↧ Expand context

                             .parse::<crate::model::TestEnum>()
                             .expect("static value validated to member"),
                     ),
                 default_int_enum: self.default_int_enum.unwrap_or(1i32),
                 empty_string: self.empty_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from(""),
                 ),
                 false_boolean: self.false_boolean.unwrap_or(false),
                 empty_blob: self.empty_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new(""),
                 ),
                 zero_byte: self.zero_byte.unwrap_or(0i8),
                 zero_short: self.zero_short.unwrap_or(0i16),
                 zero_integer: self.zero_integer.unwrap_or(0i32),
                 zero_long: self.zero_long.unwrap_or(0i64),
                 zero_float: self.zero_float.unwrap_or(0.0f32),
                 zero_double: self.zero_double.unwrap_or(0.0f64),
             })

tmp-codegen-diff/codegen-server-test/json_rpc10/rust-server-codegen/src/output.rs

@@ -511,511 +578,572 @@

↥ Expand context

-511
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_list(mut self, input: ::std::vec::Vec<crate::model::Dialog>) -> Self {
             self.dialog_list = Some(input);
             self
-516
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_map(
             mut self,
             input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         ) -> Self {
             self.dialog_map = Some(input);
             self
-524
+        }
         /// Consumes the builder and constructs a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
         ///
         /// The builder fails to construct a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,

         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-532
+        {
             self.build_enforcing_all_constraints()
-534
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-538
+        {
             Ok(crate::output::OperationWithNestedStructureOutput {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-544
+        }
-545
+    }
-546
+}
 /// See [`OperationWithRequiredMembersOutput`](crate::output::OperationWithRequiredMembersOutput).
 pub mod operation_with_required_members_output {
-549
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]

↧ Expand context

     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_string` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredString,
         /// `required_boolean` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredBoolean,
         /// `required_list` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredList,
         /// `required_timestamp` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredTimestamp,
         /// `required_blob` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredBlob,
         /// `required_byte` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredByte,
         /// `required_short` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredShort,
         /// `required_integer` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredInteger,
         /// `required_long` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredLong,

@@ -920,914 +1017,1005 @@

↥ Expand context

         pub fn zero_integer(mut self, input: i32) -> Self {
             self.zero_integer = Some(input);
             self
-917
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_long(mut self, input: i64) -> Self {
             self.zero_long = Some(input);
             self
-922
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_float(mut self, input: f32) -> Self {
             self.zero_float = Some(input);
             self
-927
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-932
+        }
         /// Consumes the builder and constructs a [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).

         pub fn build(self) -> crate::output::OperationWithDefaultsOutput {
             self.build_enforcing_all_constraints()
-936
+        }
         fn build_enforcing_all_constraints(self) -> crate::output::OperationWithDefaultsOutput {
             crate::output::OperationWithDefaultsOutput {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Object(::std::collections::HashMap::new()),
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::String(::std::string::String::from("hi")),
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true)),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc"),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 default_double: self.default_double.unwrap_or(1.0f64),
                 default_map: self.default_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 default_map: self.default_map.unwrap_or_default(),
                 default_enum: self.default_enum.unwrap_or(
                     "FOO"
                         .parse::<crate::model::TestEnum>()
                         .expect("static value validated to member"),
                 ),
                 default_int_enum: self.default_int_enum.unwrap_or(1i32),
                 empty_string: self.empty_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from(""),
                 ),

↧ Expand context

                 false_boolean: self.false_boolean.unwrap_or(false),
                 empty_blob: self.empty_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new(""),
                 ),
                 zero_byte: self.zero_byte.unwrap_or(0i8),
                 zero_short: self.zero_short.unwrap_or(0i16),
                 zero_integer: self.zero_integer.unwrap_or(0i32),
                 zero_long: self.zero_long.unwrap_or(0i64),
                 zero_float: self.zero_float.unwrap_or(0.0f32),
                 zero_double: self.zero_double.unwrap_or(0.0f64),
-997
+            }
-998
+        }
-999
+    }
-1000
+}
 /// See [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
 pub mod content_type_parameters_output {
-1003
     impl ::std::convert::From<Builder> for crate::output::ContentTypeParametersOutput {
         fn from(builder: Builder) -> Self {

tmp-codegen-diff/codegen-server-test/json_rpc11/rust-server-codegen/src/input.rs

@@ -931,931 +994,991 @@

↥ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-935
+                            )
-936
+        }
-937
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonUnionsInput>
-940
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-943
+        }
-944
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonUnionsInput {
         type Error = ConstraintViolation;
-947
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-950
+        }

-951
+    }
     /// A builder for [`JsonUnionsInput`](crate::input::JsonUnionsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) contents:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MyUnion>>,
-957
+    }
     impl Builder {
         /// A union with a representative set of types for members.
         pub fn contents(mut self, input: ::std::option::Option<crate::model::MyUnion>) -> Self {
             self.contents = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.contents = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-963
+        }
         /// A union with a representative set of types for members.
         pub(crate) fn set_contents(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MyUnion>>,
             >,
         ) -> Self {
             self.contents = input.map(|v| v.into());

↧ Expand context

             self
-973
+        }
         /// Consumes the builder and constructs a [`JsonUnionsInput`](crate::input::JsonUnionsInput).
         ///
         /// The builder fails to construct a [`JsonUnionsInput`](crate::input::JsonUnionsInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::JsonUnionsInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-980
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::JsonUnionsInput, ConstraintViolation> {
             Ok(crate::input::JsonUnionsInput {
                 contents: self
                     .contents
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Contents))

@@ -1235,1232 +1380,1365 @@

↥ Expand context

-1232
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1235
+        }
-1236
+    }
     /// A builder for [`JsonEnumsInput`](crate::input::JsonEnumsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) foo_enum1:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
         pub(crate) foo_enum2:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
         pub(crate) foo_enum3:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
         pub(crate) foo_enum_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
             >,
         >,
         pub(crate) foo_enum_set:

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnumSet>>,
         pub(crate) foo_enum_map: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::foo_enum_map_constrained::FooEnumMapConstrained,
             >,
         >,
-1258
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum1(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.foo_enum1 = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum1 = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1264
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum1(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.foo_enum1 = input.map(|v| v.into());
             self
-1274
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum2(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.foo_enum2 = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum2 = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1279
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum2(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.foo_enum2 = input.map(|v| v.into());
             self
-1289
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum3(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.foo_enum3 = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum3 = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1294
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum3(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.foo_enum3 = input.map(|v| v.into());
             self
-1304
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::FooEnum>>,
         ) -> Self {
             self.foo_enum_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-1315
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
                     >,
                 >,
             >,
         ) -> Self {
             self.foo_enum_list = input.map(|v| v.into());
             self
-1329
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum_set(
             mut self,
             input: ::std::option::Option<crate::model::FooEnumSet>,
         ) -> Self {
             self.foo_enum_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1337
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::FooEnumSet>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.foo_enum_set = input.map(|v| v.into());
             self
-1349
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum_map(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<::std::string::String, crate::model::FooEnum>,
             >,
         ) -> Self {
             self.foo_enum_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-1362
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum_map(
             mut self,

tmp-codegen-diff/codegen-server-test/misc/rust-server-codegen/src/input.rs

@@ -405,405 +468,465 @@

↥ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-409
+                            )
-410
+        }
-411
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::RequiredInnerShapeOperationInput>
-414
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-417
+        }
-418
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::RequiredInnerShapeOperationInput {
         type Error = ConstraintViolation;
-421
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-424
+        }

-425
+    }
     /// A builder for [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) inner:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::InnerShape>>,
-431
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn inner(mut self, input: ::std::option::Option<crate::model::InnerShape>) -> Self {
             self.inner = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.inner = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-437
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_inner(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::InnerShape>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.inner = input.map(|v| v.into());
             self
-449
+        }
         /// Consumes the builder and constructs a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
         ///
         /// The builder fails to construct a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::input::RequiredInnerShapeOperationInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-458
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::RequiredInnerShapeOperationInput, ConstraintViolation> {
             Ok(crate::input::RequiredInnerShapeOperationInput {
                 inner: self
                     .inner
                     .map(|v| match v {

tmp-codegen-diff/codegen-server-test/naming_test_ops/rust-server-codegen/src/input.rs

@@ -386,386 +449,446 @@

↥ Expand context

         pub(crate) build_value: ::std::option::Option<::std::string::String>,
         pub(crate) default_value: ::std::option::Option<::std::string::String>,
         pub(crate) send: ::std::option::Option<::std::string::String>,
-389
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#as(mut self, input: ::std::option::Option<i32>) -> Self {
             self.r#as = input;
             self
-395
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_as(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.r#as = input.map(|v| v.into());
             self
-400
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#async(mut self, input: ::std::option::Option<bool>) -> Self {
             self.r#async = input;
             self
-405
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_async(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.r#async = input.map(|v| v.into());
             self
-410
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
         ) -> Self {
             self.r#enum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-418
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-430
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn self_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.self_ = input;
             self
-435
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_self(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.self_ = input.map(|v| v.into());
             self
-440
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn crate_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.crate_ = input;
             self
-445
+        }
         #[allow(missing_docs)] // documentation missing in model

@@ -613,610 +676,670 @@

↥ Expand context

         pub(crate) build_value: ::std::option::Option<::std::string::String>,
         pub(crate) default_value: ::std::option::Option<::std::string::String>,
         pub(crate) send: ::std::option::Option<::std::string::String>,
-613
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#as(mut self, input: ::std::option::Option<i32>) -> Self {
             self.r#as = input;
             self
-619
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_as(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.r#as = input.map(|v| v.into());
             self
-624
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#async(mut self, input: ::std::option::Option<bool>) -> Self {
             self.r#async = input;
             self
-629
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_async(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.r#async = input.map(|v| v.into());
             self
-634
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
         ) -> Self {
             self.r#enum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-642
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-654
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn self_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.self_ = input;
             self
-659
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_self(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.self_ = input.map(|v| v.into());
             self
-664
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn crate_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.crate_ = input;
             self
-669
+        }
         #[allow(missing_docs)] // documentation missing in model

@@ -993,987 +1056,1047 @@

↥ Expand context

         pub(crate) build_value: ::std::option::Option<::std::string::String>,
         pub(crate) default_value: ::std::option::Option<::std::string::String>,
         pub(crate) send: ::std::option::Option<::std::string::String>,
-990
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#as(mut self, input: ::std::option::Option<i32>) -> Self {
             self.r#as = input;
             self
-996
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_as(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.r#as = input.map(|v| v.into());
             self
-1001
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#async(mut self, input: ::std::option::Option<bool>) -> Self {
             self.r#async = input;
             self
-1006
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_async(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.r#async = input.map(|v| v.into());
             self
-1011
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::UnknownVariantCollidingEnum>,
         ) -> Self {
             self.r#enum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1019
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::UnknownVariantCollidingEnum>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-1031
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn self_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.self_ = input;
             self
-1036
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_self(mut self, input: Option<impl ::std::convert::Into<bool>>) -> Self {
             self.self_ = input.map(|v| v.into());
             self
-1041
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn crate_(mut self, input: ::std::option::Option<bool>) -> Self {
             self.crate_ = input;
             self
-1046
+        }
         #[allow(missing_docs)] // documentation missing in model

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

@@ -3414,3414 +3477,3474 @@

↥ Expand context

-3414
+                            )
-3415
+        }
-3416
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::OperationWithDefaultsInput>
-3419
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-3422
+        }
-3423
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::OperationWithDefaultsInput {
         type Error = ConstraintViolation;
-3426
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-3429
+        }
-3430
+    }
     /// A builder for [`OperationWithDefaultsInput`](crate::input::OperationWithDefaultsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {

         pub(crate) defaults:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Defaults>>,
         pub(crate) client_optional_defaults:
             ::std::option::Option<crate::model::ClientOptionalDefaults>,
         pub(crate) top_level_default: ::std::option::Option<::std::string::String>,
         pub(crate) other_top_level_default: ::std::option::Option<i32>,
-3440
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn defaults(mut self, input: ::std::option::Option<crate::model::Defaults>) -> Self {
             self.defaults = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.defaults = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3446
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_defaults(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Defaults>>,
             >,
         ) -> Self {
             self.defaults = input.map(|v| v.into());

↧ Expand context

             self
-3456
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn client_optional_defaults(
             mut self,
             input: ::std::option::Option<crate::model::ClientOptionalDefaults>,
         ) -> Self {
             self.client_optional_defaults = input;
             self
-3464
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_client_optional_defaults(
             mut self,
             input: Option<impl ::std::convert::Into<crate::model::ClientOptionalDefaults>>,
         ) -> Self {
             self.client_optional_defaults = input.map(|v| v.into());
             self
-3472
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn top_level_default(mut self, input: ::std::string::String) -> Self {

@@ -6976,6973 +7039,7033 @@

↥ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-6977
+                            )
-6978
+        }
-6979
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonUnionsInput>
-6982
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-6985
+        }
-6986
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonUnionsInput {
         type Error = ConstraintViolation;
-6989
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-6992
+        }

-6993
+    }
     /// A builder for [`JsonUnionsInput`](crate::input::JsonUnionsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) contents:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MyUnion>>,
-6999
+    }
     impl Builder {
         /// A union with a representative set of types for members.
         pub fn contents(mut self, input: ::std::option::Option<crate::model::MyUnion>) -> Self {
             self.contents = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.contents = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7005
+        }
         /// A union with a representative set of types for members.
         pub(crate) fn set_contents(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MyUnion>>,
             >,
         ) -> Self {
             self.contents = input.map(|v| v.into());

↧ Expand context

             self
-7015
+        }
         /// Consumes the builder and constructs a [`JsonUnionsInput`](crate::input::JsonUnionsInput).
         ///
         /// The builder fails to construct a [`JsonUnionsInput`](crate::input::JsonUnionsInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::JsonUnionsInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-7022
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::JsonUnionsInput, ConstraintViolation> {
             Ok(crate::input::JsonUnionsInput {
                 contents: self
                     .contents
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::Contents))

@@ -7855,7849 +7918,7909 @@

↥ Expand context

         pub(crate) enum_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
             >,
         >,
         pub(crate) int_enum_list: ::std::option::Option<::std::vec::Vec<i32>>,
         pub(crate) nested_string_list:
             ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
         pub(crate) structure_list:
             ::std::option::Option<::std::vec::Vec<crate::model::StructureListMember>>,
-7859
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn string_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         ) -> Self {
             self.string_list = input;
             self
-7868
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string_list(
             mut self,
             input: Option<impl ::std::convert::Into<::std::vec::Vec<::std::string::String>>>,
         ) -> Self {
             self.string_list = input.map(|v| v.into());
             self
-7876
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn string_set(mut self, input: ::std::option::Option<crate::model::StringSet>) -> Self {
             self.string_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-7881
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::StringSet>>,
             >,
         ) -> Self {
             self.string_set = input.map(|v| v.into());

↧ Expand context

             self
-7891
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer_list(mut self, input: ::std::option::Option<::std::vec::Vec<i32>>) -> Self {
             self.integer_list = input;
             self
-7896
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer_list(
             mut self,
             input: Option<impl ::std::convert::Into<::std::vec::Vec<i32>>>,
         ) -> Self {
             self.integer_list = input.map(|v| v.into());
             self
-7904
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn boolean_list(mut self, input: ::std::option::Option<::std::vec::Vec<bool>>) -> Self {
             self.boolean_list = input;
             self
-7909
+        }

@@ -8208,8199 +8271,8259 @@

↥ Expand context

-8199
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer_enum3(
             mut self,
             input: Option<impl ::std::convert::Into<i32>>,
         ) -> Self {
             self.integer_enum3 = input.map(|v| v.into());
             self
-8207
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer_enum_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<i32>>,
         ) -> Self {
             self.integer_enum_list = input;
             self
-8215
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer_enum_list(
             mut self,

             input: Option<impl ::std::convert::Into<::std::vec::Vec<i32>>>,
         ) -> Self {
             self.integer_enum_list = input.map(|v| v.into());
             self
-8223
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer_enum_set(
             mut self,
             input: ::std::option::Option<crate::model::IntegerEnumSet>,
         ) -> Self {
             self.integer_enum_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.integer_enum_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-8231
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer_enum_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::IntegerEnumSet>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.integer_enum_set = input.map(|v| v.into());
             self
-8243
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer_enum_map(
             mut self,
             input: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
         ) -> Self {
             self.integer_enum_map = input;
             self
-8251
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer_enum_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<::std::collections::HashMap<::std::string::String, i32>>,
             >,
         ) -> Self {
             self.integer_enum_map = input.map(|v| v.into());

@@ -8397,8385 +8542,8518 @@

↥ Expand context

-8385
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-8388
+        }
-8389
+    }
     /// A builder for [`JsonEnumsInput`](crate::input::JsonEnumsInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) foo_enum1:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
         pub(crate) foo_enum2:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
         pub(crate) foo_enum3:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
         pub(crate) foo_enum_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
             >,
         >,
         pub(crate) foo_enum_set:

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnumSet>>,
         pub(crate) foo_enum_map: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::foo_enum_map_constrained::FooEnumMapConstrained,
             >,
         >,
-8411
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum1(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.foo_enum1 = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum1 = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-8417
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum1(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.foo_enum1 = input.map(|v| v.into());
             self
-8427
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum2(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.foo_enum2 = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum2 = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-8432
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum2(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.foo_enum2 = input.map(|v| v.into());
             self
-8442
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum3(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.foo_enum3 = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum3 = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-8447
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum3(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.foo_enum3 = input.map(|v| v.into());
             self
-8457
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::FooEnum>>,
         ) -> Self {
             self.foo_enum_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-8468
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
                     >,
                 >,
             >,
         ) -> Self {
             self.foo_enum_list = input.map(|v| v.into());
             self
-8482
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum_set(
             mut self,
             input: ::std::option::Option<crate::model::FooEnumSet>,
         ) -> Self {
             self.foo_enum_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.foo_enum_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-8490
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::FooEnumSet>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.foo_enum_set = input.map(|v| v.into());
             self
-8502
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo_enum_map(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<::std::string::String, crate::model::FooEnum>,
             >,
         ) -> Self {
             self.foo_enum_map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-8515
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo_enum_map(
             mut self,

@@ -9271,9247 +9334,9307 @@

↥ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-9251
+                            )
-9252
+        }
-9253
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::HttpEnumPayloadInput>
-9256
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-9259
+        }
-9260
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpEnumPayloadInput {
         type Error = ConstraintViolation;
-9263
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-9266
+        }

-9267
+    }
     /// A builder for [`HttpEnumPayloadInput`](crate::input::HttpEnumPayloadInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) payload:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::StringEnum>>,
-9273
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn payload(mut self, input: ::std::option::Option<crate::model::StringEnum>) -> Self {
             self.payload = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.payload = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-9279
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_payload(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::StringEnum>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.payload = input.map(|v| v.into());
             self
-9291
+        }
         /// Consumes the builder and constructs a [`HttpEnumPayloadInput`](crate::input::HttpEnumPayloadInput).
         ///
         /// The builder fails to construct a [`HttpEnumPayloadInput`](crate::input::HttpEnumPayloadInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::HttpEnumPayloadInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-9298
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::HttpEnumPayloadInput, ConstraintViolation> {
             Ok(crate::input::HttpEnumPayloadInput {
                 payload: self
                     .payload
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

@@ -10348,10321 +10411,10381 @@

↥ Expand context

-10321
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_string(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.query_string = input.map(|v| v.into());
             self
-10329
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_string_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         ) -> Self {
             self.query_string_list = input;
             self
-10337
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_string_list(
             mut self,

             input: Option<impl ::std::convert::Into<::std::vec::Vec<::std::string::String>>>,
         ) -> Self {
             self.query_string_list = input.map(|v| v.into());
             self
-10345
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_string_set(
             mut self,
             input: ::std::option::Option<crate::model::StringSet>,
         ) -> Self {
             self.query_string_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.query_string_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-10353
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_string_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::StringSet>>,
             >,
         ) -> Self {
             self.query_string_set = input.map(|v| v.into());

↧ Expand context

             self
-10363
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_byte(mut self, input: ::std::option::Option<i8>) -> Self {
             self.query_byte = input;
             self
-10368
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_byte(
             mut self,
             input: Option<impl ::std::convert::Into<i8>>,
         ) -> Self {
             self.query_byte = input.map(|v| v.into());
             self
-10376
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_short(mut self, input: ::std::option::Option<i16>) -> Self {
             self.query_short = input;
             self
-10381
+        }

@@ -10424,10394 +10487,10454 @@

↥ Expand context

-10394
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_integer(
             mut self,
             input: Option<impl ::std::convert::Into<i32>>,
         ) -> Self {
             self.query_integer = input.map(|v| v.into());
             self
-10402
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_integer_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<i32>>,
         ) -> Self {
             self.query_integer_list = input;
             self
-10410
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_integer_list(
             mut self,

             input: Option<impl ::std::convert::Into<::std::vec::Vec<i32>>>,
         ) -> Self {
             self.query_integer_list = input.map(|v| v.into());
             self
-10418
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_integer_set(
             mut self,
             input: ::std::option::Option<crate::model::IntegerSet>,
         ) -> Self {
             self.query_integer_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.query_integer_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-10426
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_integer_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::IntegerSet>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.query_integer_set = input.map(|v| v.into());
             self
-10438
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_long(mut self, input: ::std::option::Option<i64>) -> Self {
             self.query_long = input;
             self
-10443
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_long(
             mut self,
             input: Option<impl ::std::convert::Into<i64>>,
         ) -> Self {
             self.query_long = input.map(|v| v.into());
             self
-10451
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_float(mut self, input: ::std::option::Option<f32>) -> Self {
             self.query_float = input;

@@ -10560,10527 +10623,10587 @@

↥ Expand context

         ) -> Self {
             self.query_timestamp = input;
             self
-10530
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_timestamp(
             mut self,
             input: Option<impl ::std::convert::Into<::aws_smithy_types::DateTime>>,
         ) -> Self {
             self.query_timestamp = input.map(|v| v.into());
             self
-10538
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_timestamp_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
         ) -> Self {
             self.query_timestamp_list = input;
             self
-10546
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_timestamp_list(
             mut self,
             input: Option<impl ::std::convert::Into<::std::vec::Vec<::aws_smithy_types::DateTime>>>,
         ) -> Self {
             self.query_timestamp_list = input.map(|v| v.into());
             self
-10554
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_enum(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.query_enum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.query_enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-10559
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.query_enum = input.map(|v| v.into());

↧ Expand context

             self
-10569
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn query_enum_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::FooEnum>>,
         ) -> Self {
             self.query_enum_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-10580
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_query_enum_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,

@@ -12159,12123 +12222,12183 @@

↥ Expand context

-12123
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_false_bool(
             mut self,
             input: Option<impl ::std::convert::Into<bool>>,
         ) -> Self {
             self.header_false_bool = input.map(|v| v.into());
             self
-12131
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_string_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         ) -> Self {
             self.header_string_list = input;
             self
-12139
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_string_list(
             mut self,

             input: Option<impl ::std::convert::Into<::std::vec::Vec<::std::string::String>>>,
         ) -> Self {
             self.header_string_list = input.map(|v| v.into());
             self
-12147
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_string_set(
             mut self,
             input: ::std::option::Option<crate::model::StringSet>,
         ) -> Self {
             self.header_string_set = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.header_string_set = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-12155
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_string_set(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::StringSet>>,
             >,
         ) -> Self {
             self.header_string_set = input.map(|v| v.into());

↧ Expand context

             self
-12165
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_integer_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<i32>>,
         ) -> Self {
             self.header_integer_list = input;
             self
-12173
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_integer_list(
             mut self,
             input: Option<impl ::std::convert::Into<::std::vec::Vec<i32>>>,
         ) -> Self {
             self.header_integer_list = input.map(|v| v.into());
             self
-12181
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_boolean_list(

@@ -12225,12186 +12288,12246 @@

↥ Expand context

         ) -> Self {
             self.header_boolean_list = input;
             self
-12189
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_boolean_list(
             mut self,
             input: Option<impl ::std::convert::Into<::std::vec::Vec<bool>>>,
         ) -> Self {
             self.header_boolean_list = input.map(|v| v.into());
             self
-12197
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_timestamp_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::DateTime>>,
         ) -> Self {
             self.header_timestamp_list = input;
             self
-12205
+        }

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_timestamp_list(
             mut self,
             input: Option<impl ::std::convert::Into<::std::vec::Vec<::aws_smithy_types::DateTime>>>,
         ) -> Self {
             self.header_timestamp_list = input.map(|v| v.into());
             self
-12213
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_enum(mut self, input: ::std::option::Option<crate::model::FooEnum>) -> Self {
             self.header_enum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.header_enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-12218
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::FooEnum>>,
             >,
         ) -> Self {
             self.header_enum = input.map(|v| v.into());

↧ Expand context

             self
-12228
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn header_enum_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::FooEnum>>,
         ) -> Self {
             self.header_enum_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-12239
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_header_enum_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,

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

@@ -1801,1801 +1868,1862 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_map(
             mut self,
             input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         ) -> Self {
             self.dialog_map = Some(input);
             self
-1808
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_dialog_map(
             mut self,
             input: impl ::std::convert::Into<
                 ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
             >,
         ) -> Self {
             self.dialog_map = Some(input.into());
             self
-1818
+        }
         /// Consumes the builder and constructs a [`TopLevel`](crate::model::TopLevel).
         ///

         /// The builder fails to construct a [`TopLevel`](crate::model::TopLevel) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::TopLevel, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1825
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::TopLevel, ConstraintViolation> {
             Ok(crate::model::TopLevel {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-1834
+        }
-1835
+    }
-1836
+}
 /// See [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
 pub mod client_optional_defaults {
-1839
     impl ::std::convert::From<Builder> for crate::model::ClientOptionalDefaults {
         fn from(builder: Builder) -> Self {
             builder.build()

↧ Expand context

-1843
+        }
-1844
+    }
     /// A builder for [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) member: ::std::option::Option<i32>,
-1849
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn member(mut self, input: i32) -> Self {
             self.member = Some(input);
             self
-1855
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_member(mut self, input: impl ::std::convert::Into<i32>) -> Self {
             self.member = Some(input.into());
             self
-1860
+        }
         /// Consumes the builder and constructs a [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
         pub fn build(self) -> crate::model::ClientOptionalDefaults {

@@ -2281,2275 +2378,2366 @@

↥ Expand context

         pub(crate) fn set_zero_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
             self.zero_float = Some(input.into());
             self
-2278
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-2283
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_zero_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
             self.zero_double = Some(input.into());
             self
-2288
+        }
         /// Consumes the builder and constructs a [`Defaults`](crate::model::Defaults).
         ///
         /// The builder fails to construct a [`Defaults`](crate::model::Defaults) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::Defaults, ConstraintViolation> {
             self.build_enforcing_all_constraints()

-2295
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::Defaults, ConstraintViolation> {
             Ok(crate::model::Defaults {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Object(::std::collections::HashMap::new()),
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::String(::std::string::String::from("hi")),
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true)),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc"),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 default_double: self.default_double.unwrap_or(1.0f64),
                 default_map: self.default_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 default_map: self.default_map.unwrap_or_default(),
                 default_enum: self
                     .default_enum
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::DefaultEnum))
                     .transpose()?
                     .unwrap_or(
                         "FOO"

↧ Expand context

                             .parse::<crate::model::TestEnum>()
                             .expect("static value validated to member"),
                     ),
                 default_int_enum: self.default_int_enum.unwrap_or(1i32),
                 empty_string: self.empty_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from(""),
                 ),
                 false_boolean: self.false_boolean.unwrap_or(false),
                 empty_blob: self.empty_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new(""),
                 ),
                 zero_byte: self.zero_byte.unwrap_or(0i8),
                 zero_short: self.zero_short.unwrap_or(0i16),
                 zero_integer: self.zero_integer.unwrap_or(0i32),
                 zero_long: self.zero_long.unwrap_or(0i64),
                 zero_float: self.zero_float.unwrap_or(0.0f32),
                 zero_double: self.zero_double.unwrap_or(0.0f64),
             })

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

@@ -2420,2420 +2487,2481 @@

↥ Expand context

-2420
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_list(mut self, input: ::std::vec::Vec<crate::model::Dialog>) -> Self {
             self.dialog_list = Some(input);
             self
-2425
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_map(
             mut self,
             input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         ) -> Self {
             self.dialog_map = Some(input);
             self
-2433
+        }
         /// Consumes the builder and constructs a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
         ///
         /// The builder fails to construct a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,

         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-2441
+        {
             self.build_enforcing_all_constraints()
-2443
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-2447
+        {
             Ok(crate::output::OperationWithNestedStructureOutput {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-2453
+        }
-2454
+    }
-2455
+}
 /// See [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
 pub mod operation_with_defaults_output {
-2458
     impl ::std::convert::From<Builder> for crate::output::OperationWithDefaultsOutput {
         fn from(builder: Builder) -> Self {
             builder.build()

↧ Expand context

-2462
+        }
-2463
+    }
     /// A builder for [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) default_string: ::std::option::Option<::std::string::String>,
         pub(crate) default_boolean: ::std::option::Option<bool>,
         pub(crate) default_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         pub(crate) default_document_map: ::std::option::Option<::aws_smithy_types::Document>,
         pub(crate) default_document_string: ::std::option::Option<::aws_smithy_types::Document>,
         pub(crate) default_document_boolean: ::std::option::Option<::aws_smithy_types::Document>,
         pub(crate) default_document_list: ::std::option::Option<::aws_smithy_types::Document>,
         pub(crate) default_null_document: ::std::option::Option<::aws_smithy_types::Document>,
         pub(crate) default_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
         pub(crate) default_blob: ::std::option::Option<::aws_smithy_types::Blob>,
         pub(crate) default_byte: ::std::option::Option<i8>,
         pub(crate) default_short: ::std::option::Option<i16>,
         pub(crate) default_integer: ::std::option::Option<i32>,
         pub(crate) default_long: ::std::option::Option<i64>,
         pub(crate) default_float: ::std::option::Option<f32>,

@@ -2632,2626 +2729,2717 @@

↥ Expand context

         pub fn zero_integer(mut self, input: i32) -> Self {
             self.zero_integer = Some(input);
             self
-2629
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_long(mut self, input: i64) -> Self {
             self.zero_long = Some(input);
             self
-2634
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_float(mut self, input: f32) -> Self {
             self.zero_float = Some(input);
             self
-2639
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-2644
+        }
         /// Consumes the builder and constructs a [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).

         pub fn build(self) -> crate::output::OperationWithDefaultsOutput {
             self.build_enforcing_all_constraints()
-2648
+        }
         fn build_enforcing_all_constraints(self) -> crate::output::OperationWithDefaultsOutput {
             crate::output::OperationWithDefaultsOutput {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Object(::std::collections::HashMap::new()),
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::String(::std::string::String::from("hi")),
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true)),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc"),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 default_double: self.default_double.unwrap_or(1.0f64),
                 default_map: self.default_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 default_map: self.default_map.unwrap_or_default(),
                 default_enum: self.default_enum.unwrap_or(
                     "FOO"
                         .parse::<crate::model::TestEnum>()
                         .expect("static value validated to member"),
                 ),
                 default_int_enum: self.default_int_enum.unwrap_or(1i32),
                 empty_string: self.empty_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from(""),
                 ),

↧ Expand context

                 false_boolean: self.false_boolean.unwrap_or(false),
                 empty_blob: self.empty_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new(""),
                 ),
                 zero_byte: self.zero_byte.unwrap_or(0i8),
                 zero_short: self.zero_short.unwrap_or(0i16),
                 zero_integer: self.zero_integer.unwrap_or(0i32),
                 zero_long: self.zero_long.unwrap_or(0i64),
                 zero_float: self.zero_float.unwrap_or(0.0f32),
                 zero_double: self.zero_double.unwrap_or(0.0f64),
-2709
+            }
-2710
+        }
-2711
+    }
-2712
+}
 /// See [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
 pub mod content_type_parameters_output {
-2715
     impl ::std::convert::From<Builder> for crate::output::ContentTypeParametersOutput {
         fn from(builder: Builder) -> Self {

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/input.rs

@@ -420,420 +483,480 @@

↥ Expand context

-420
+        }
-421
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::EscapedStringValuesInput>
-424
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-427
+        }
-428
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::EscapedStringValuesInput {
         type Error = ConstraintViolation;
-431
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-434
+        }
-435
+    }
     /// A builder for [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) r#enum: ::std::option::Option<

             crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>,
         >,
         pub(crate) some_string: ::std::option::Option<::std::string::String>,
-443
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn r#enum(
             mut self,
             input: ::std::option::Option<crate::model::EnumWithEscapedChars>,
         ) -> Self {
             self.r#enum = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-452
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>,
                 >,
             >,

↧ Expand context

         ) -> Self {
             self.r#enum = input.map(|v| v.into());
             self
-464
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn some_string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.some_string = input;
             self
-469
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_some_string(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.some_string = input.map(|v| v.into());
             self
-477
+        }
         /// Consumes the builder and constructs a [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput).
         ///
         /// The builder fails to construct a [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput) if a [`ConstraintViolation`] occurs.

Pages: 1 2