Server Test

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

@@ -793,793 +856,853 @@

-793
+                            )
-794
+        }
-795
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::SensitiveValidationInput>
-798
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-801
+        }
-802
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::SensitiveValidationInput {
         type Error = ConstraintViolation;
-805
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-808
+        }
-809
+    }
     /// A builder for [`SensitiveValidationInput`](crate::input::SensitiveValidationInput).
     #[derive(::std::clone::Clone, ::std::default::Default)]
     pub struct Builder {

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

↧ Expand context

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

@@ -919,916 +982,976 @@

↥ Expand context

-916
+                            )
-917
+        }
-918
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::RecursiveStructuresInput>
-921
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-924
+        }
-925
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::RecursiveStructuresInput {
         type Error = ConstraintViolation;
-928
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-931
+        }
-932
+    }
     /// A builder for [`RecursiveStructuresInput`](crate::input::RecursiveStructuresInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {

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

↧ Expand context

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

@@ -1171,1165 +1549,1496 @@

↥ Expand context

         pub(crate) short_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::ShortSet>>,
         pub(crate) integer_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::IntegerSet>>,
         pub(crate) long_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LongSet>>,
         pub(crate) timestamp_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::TimestampSet>>,
         pub(crate) date_time_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::DateTimeSet>>,
         pub(crate) http_date_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::HttpDateSet>>,
         pub(crate) enum_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::FooEnumSet>>,
         pub(crate) int_enum_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::IntegerEnumSet>,
         >,
         pub(crate) list_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::ListSet>>,
         pub(crate) structure_list:

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::StructureSet>>,
         pub(crate) structure_list_with_no_key: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::StructureSetWithNoKey>,
         >,
         pub(crate) union_list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::UnionSet>>,
-1191
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn blob_list(mut self, input: ::std::option::Option<crate::model::BlobSet>) -> Self {
             self.blob_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.blob_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1197
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_blob_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::BlobSet>>,
             >,
         ) -> Self {
             self.blob_list = input.map(|v| v.into());
             self
-1207
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn boolean_list(
             mut self,
             input: ::std::option::Option<crate::model::BooleanSet>,
         ) -> Self {
             self.boolean_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.boolean_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1215
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_boolean_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::BooleanSet>,
                 >,
             >,
         ) -> Self {
             self.boolean_list = input.map(|v| v.into());
             self
-1227
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn string_list(
             mut self,
             input: ::std::option::Option<crate::model::StringSet>,
         ) -> Self {
             self.string_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1235
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::StringSet>>,
             >,
         ) -> Self {
             self.string_list = input.map(|v| v.into());
             self
-1245
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn byte_list(mut self, input: ::std::option::Option<crate::model::ByteSet>) -> Self {
             self.byte_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.byte_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1250
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_byte_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ByteSet>>,
             >,
         ) -> Self {
             self.byte_list = input.map(|v| v.into());
             self
-1260
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn short_list(mut self, input: ::std::option::Option<crate::model::ShortSet>) -> Self {
             self.short_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.short_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1265
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_short_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ShortSet>>,
             >,
         ) -> Self {
             self.short_list = input.map(|v| v.into());
             self
-1275
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer_list(
             mut self,
             input: ::std::option::Option<crate::model::IntegerSet>,
         ) -> Self {
             self.integer_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.integer_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1283
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::IntegerSet>,
                 >,
             >,
         ) -> Self {
             self.integer_list = input.map(|v| v.into());
             self
-1295
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn long_list(mut self, input: ::std::option::Option<crate::model::LongSet>) -> Self {
             self.long_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.long_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1300
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_long_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::LongSet>>,
             >,
         ) -> Self {
             self.long_list = input.map(|v| v.into());
             self
-1310
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn timestamp_list(
             mut self,
             input: ::std::option::Option<crate::model::TimestampSet>,
         ) -> Self {
             self.timestamp_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.timestamp_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1318
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_timestamp_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::TimestampSet>,
                 >,
             >,
         ) -> Self {
             self.timestamp_list = input.map(|v| v.into());
             self
-1330
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn date_time_list(
             mut self,
             input: ::std::option::Option<crate::model::DateTimeSet>,
         ) -> Self {
             self.date_time_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.date_time_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1338
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_date_time_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::DateTimeSet>,
                 >,
             >,
         ) -> Self {
             self.date_time_list = input.map(|v| v.into());
             self
-1350
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn http_date_list(
             mut self,
             input: ::std::option::Option<crate::model::HttpDateSet>,
         ) -> Self {
             self.http_date_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.http_date_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1358
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_http_date_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::HttpDateSet>,
                 >,
             >,
         ) -> Self {
             self.http_date_list = input.map(|v| v.into());
             self
-1370
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn enum_list(mut self, input: ::std::option::Option<crate::model::FooEnumSet>) -> Self {
             self.enum_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.enum_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1375
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_enum_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::FooEnumSet>,
                 >,
             >,
         ) -> Self {
             self.enum_list = input.map(|v| v.into());
             self
-1387
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn int_enum_list(
             mut self,
             input: ::std::option::Option<crate::model::IntegerEnumSet>,
         ) -> Self {
             self.int_enum_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.int_enum_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1395
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_int_enum_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::IntegerEnumSet>,
                 >,
             >,
         ) -> Self {
             self.int_enum_list = input.map(|v| v.into());
             self
-1407
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list_list(mut self, input: ::std::option::Option<crate::model::ListSet>) -> Self {
             self.list_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.list_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1412
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::ListSet>>,
             >,
         ) -> Self {
             self.list_list = input.map(|v| v.into());
             self
-1422
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn structure_list(
             mut self,
             input: ::std::option::Option<crate::model::StructureSet>,
         ) -> Self {
             self.structure_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.structure_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1430
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_structure_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::StructureSet>,
                 >,
             >,
         ) -> Self {
             self.structure_list = input.map(|v| v.into());
             self
-1442
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn structure_list_with_no_key(
             mut self,
             input: ::std::option::Option<crate::model::StructureSetWithNoKey>,
         ) -> Self {
             self.structure_list_with_no_key = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.structure_list_with_no_key =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1451
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_structure_list_with_no_key(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::StructureSetWithNoKey>,
                 >,
             >,
         ) -> Self {
             self.structure_list_with_no_key = input.map(|v| v.into());
             self
-1463
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn union_list(mut self, input: ::std::option::Option<crate::model::UnionSet>) -> Self {
             self.union_list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.union_list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1468
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_union_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::UnionSet>>,
             >,
         ) -> Self {
             self.union_list = input.map(|v| v.into());

↧ Expand context

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

@@ -2010,1957 +2348,2259 @@

↥ Expand context

         pub(crate) max_integer: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_range_override_input::MaxInteger,
             >,
         >,
         pub(crate) long: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_range_override_input::Long,
             >,
         >,
         pub(crate) min_long: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_range_override_input::MinLong,
             >,
         >,
         pub(crate) max_long: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_range_override_input::MaxLong,
             >,
         >,

         pub(crate) float: ::std::option::Option<f32>,
         pub(crate) min_float: ::std::option::Option<f32>,
         pub(crate) max_float: ::std::option::Option<f32>,
-1980
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn byte(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::Byte>,
         ) -> Self {
             self.byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-1989
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::Byte,
                     >,
                 >,
             >,
         ) -> Self {
             self.byte = input.map(|v| v.into());
             self
-2003
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_byte(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MinByte>,
         ) -> Self {
             self.min_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2011
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MinByte,
                     >,
                 >,
             >,
         ) -> Self {
             self.min_byte = input.map(|v| v.into());
             self
-2025
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_byte(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MaxByte>,
         ) -> Self {
             self.max_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2033
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MaxByte,
                     >,
                 >,
             >,
         ) -> Self {
             self.max_byte = input.map(|v| v.into());
             self
-2047
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn short(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::Short>,
         ) -> Self {
             self.short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2055
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::Short,
                     >,
                 >,
             >,
         ) -> Self {
             self.short = input.map(|v| v.into());
             self
-2069
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_short(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MinShort>,
         ) -> Self {
             self.min_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2077
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MinShort,
                     >,
                 >,
             >,
         ) -> Self {
             self.min_short = input.map(|v| v.into());
             self
-2091
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_short(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MaxShort>,
         ) -> Self {
             self.max_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2099
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MaxShort,
                     >,
                 >,
             >,
         ) -> Self {
             self.max_short = input.map(|v| v.into());
             self
-2113
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::Integer>,
         ) -> Self {
             self.integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.integer = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2121
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::Integer,
                     >,
                 >,
             >,
         ) -> Self {
             self.integer = input.map(|v| v.into());
             self
-2135
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_integer(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MinInteger>,
         ) -> Self {
             self.min_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_integer = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2143
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MinInteger,
                     >,
                 >,
             >,
         ) -> Self {
             self.min_integer = input.map(|v| v.into());
             self
-2157
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_integer(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MaxInteger>,
         ) -> Self {
             self.max_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_integer = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2165
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MaxInteger,
                     >,
                 >,
             >,
         ) -> Self {
             self.max_integer = input.map(|v| v.into());
             self
-2179
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn long(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::Long>,
         ) -> Self {
             self.long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2187
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::Long,
                     >,
                 >,
             >,
         ) -> Self {
             self.long = input.map(|v| v.into());
             self
-2201
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_long(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MinLong>,
         ) -> Self {
             self.min_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2209
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MinLong,
                     >,
                 >,
             >,
         ) -> Self {
             self.min_long = input.map(|v| v.into());
             self
-2223
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_long(
             mut self,
             input: ::std::option::Option<crate::input::malformed_range_override_input::MaxLong>,
         ) -> Self {
             self.max_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-2231
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_range_override_input::MaxLong,
                     >,

↧ Expand context

                 >,
             >,
         ) -> Self {
             self.max_long = input.map(|v| v.into());
             self
-2245
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn float(mut self, input: ::std::option::Option<f32>) -> Self {
             self.float = input;
             self
-2250
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_float(mut self, input: Option<impl ::std::convert::Into<f32>>) -> Self {
             self.float = input.map(|v| v.into());
             self
-2255
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_float(mut self, input: ::std::option::Option<f32>) -> Self {
             self.min_float = input;
             self

@@ -3903,3814 +4178,4053 @@

↥ Expand context

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::RangeByte>>,
         pub(crate) min_byte:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MinByte>>,
         pub(crate) max_byte:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MaxByte>>,
         pub(crate) short:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::RangeShort>>,
         pub(crate) min_short:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MinShort>>,
         pub(crate) max_short:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MaxShort>>,
         pub(crate) integer:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::RangeInteger>>,
         pub(crate) min_integer:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MinInteger>>,
         pub(crate) max_integer:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MaxInteger>>,
         pub(crate) long:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::RangeLong>>,
         pub(crate) min_long:

             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MinLong>>,
         pub(crate) max_long:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::MaxLong>>,
         pub(crate) float: ::std::option::Option<f32>,
         pub(crate) min_float: ::std::option::Option<f32>,
         pub(crate) max_float: ::std::option::Option<f32>,
-3840
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn byte(mut self, input: ::std::option::Option<crate::model::RangeByte>) -> Self {
             self.byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3846
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::RangeByte>>,
             >,
         ) -> Self {
             self.byte = input.map(|v| v.into());
             self
-3856
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_byte(mut self, input: ::std::option::Option<crate::model::MinByte>) -> Self {
             self.min_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3861
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MinByte>>,
             >,
         ) -> Self {
             self.min_byte = input.map(|v| v.into());
             self
-3871
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_byte(mut self, input: ::std::option::Option<crate::model::MaxByte>) -> Self {
             self.max_byte = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_byte = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3876
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_byte(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MaxByte>>,
             >,
         ) -> Self {
             self.max_byte = input.map(|v| v.into());
             self
-3886
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn short(mut self, input: ::std::option::Option<crate::model::RangeShort>) -> Self {
             self.short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3891
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::RangeShort>,
                 >,
             >,
         ) -> Self {
             self.short = input.map(|v| v.into());
             self
-3903
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_short(mut self, input: ::std::option::Option<crate::model::MinShort>) -> Self {
             self.min_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3908
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MinShort>>,
             >,
         ) -> Self {
             self.min_short = input.map(|v| v.into());
             self
-3918
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_short(mut self, input: ::std::option::Option<crate::model::MaxShort>) -> Self {
             self.max_short = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_short = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3923
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_short(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MaxShort>>,
             >,
         ) -> Self {
             self.max_short = input.map(|v| v.into());
             self
-3933
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn integer(mut self, input: ::std::option::Option<crate::model::RangeInteger>) -> Self {
             self.integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.integer = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3938
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::RangeInteger>,
                 >,
             >,
         ) -> Self {
             self.integer = input.map(|v| v.into());
             self
-3950
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_integer(
             mut self,
             input: ::std::option::Option<crate::model::MinInteger>,
         ) -> Self {
             self.min_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_integer = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3958
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MinInteger>,
                 >,
             >,
         ) -> Self {
             self.min_integer = input.map(|v| v.into());
             self
-3970
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_integer(
             mut self,
             input: ::std::option::Option<crate::model::MaxInteger>,
         ) -> Self {
             self.max_integer = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_integer = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3978
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_integer(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MaxInteger>,
                 >,
             >,
         ) -> Self {
             self.max_integer = input.map(|v| v.into());
             self
-3990
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn long(mut self, input: ::std::option::Option<crate::model::RangeLong>) -> Self {
             self.long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-3995
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::RangeLong>>,
             >,
         ) -> Self {
             self.long = input.map(|v| v.into());
             self
-4005
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_long(mut self, input: ::std::option::Option<crate::model::MinLong>) -> Self {
             self.min_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4010
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MinLong>>,
             >,
         ) -> Self {
             self.min_long = input.map(|v| v.into());
             self
-4020
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_long(mut self, input: ::std::option::Option<crate::model::MaxLong>) -> Self {
             self.max_long = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_long = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4025
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_long(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::MaxLong>>,
             >,
         ) -> Self {
             self.max_long = input.map(|v| v.into());

↧ Expand context

             self
-4035
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn float(mut self, input: ::std::option::Option<f32>) -> Self {
             self.float = input;
             self
-4040
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_float(mut self, input: Option<impl ::std::convert::Into<f32>>) -> Self {
             self.float = input.map(|v| v.into());
             self
-4045
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_float(mut self, input: ::std::option::Option<f32>) -> Self {
             self.min_float = input;
             self
-4050
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_float(
             mut self,

@@ -4382,4257 +4445,4317 @@

↥ Expand context

-4257
+        }
-4258
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedPatternOverrideInput>
-4261
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-4264
+        }
-4265
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedPatternOverrideInput {
         type Error = ConstraintViolation;
-4268
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-4271
+        }
-4272
+    }
     /// A builder for [`MalformedPatternOverrideInput`](crate::input::MalformedPatternOverrideInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) string: ::std::option::Option<crate::constrained::MaybeConstrained<crate::input::malformed_pattern_override_input::String>>,

         pub(crate) list: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::pattern_list_override_constrained::PatternListOverrideConstrained>>,
         pub(crate) map: ::std::option::Option<crate::constrained::MaybeConstrained<crate::constrained::pattern_map_override_constrained::PatternMapOverrideConstrained>>,
         pub(crate) union: ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::PatternUnionOverride>>,
-4280
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn string(
             mut self,
             input: ::std::option::Option<crate::input::malformed_pattern_override_input::String>,
         ) -> Self {
             self.string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4289
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_pattern_override_input::String,
                     >,

↧ Expand context

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

@@ -4452,4324 +4515,4384 @@

↥ Expand context

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

             input: Option<impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::constrained::pattern_map_override_constrained::PatternMapOverrideConstrained>>>,
         ) -> Self {
             self.map = input.map(|v| v.into());
             self
-4348
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn union(
             mut self,
             input: ::std::option::Option<crate::model::PatternUnionOverride>,
         ) -> Self {
             self.union = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.union = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4356
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_union(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::PatternUnionOverride>,
                 >,
             >,

↧ Expand context

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

@@ -4779,4648 +4865,4728 @@

↥ Expand context

         type Error = ConstraintViolation;
-4649
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-4652
+        }
-4653
+    }
     /// A builder for [`MalformedPatternInput`](crate::input::MalformedPatternInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) string: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::PatternString>,
         >,
         pub(crate) evil_string:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::EvilString>>,
         pub(crate) list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::pattern_list_constrained::PatternListConstrained,
             >,
         >,
         pub(crate) map: ::std::option::Option<

             crate::constrained::MaybeConstrained<
                 crate::constrained::pattern_map_constrained::PatternMapConstrained,
             >,
         >,
         pub(crate) union:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::PatternUnion>>,
-4674
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn string(mut self, input: ::std::option::Option<crate::model::PatternString>) -> Self {
             self.string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4680
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::PatternString>,
                 >,
             >,
         ) -> Self {
             self.string = input.map(|v| v.into());
             self
-4692
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn evil_string(
             mut self,
             input: ::std::option::Option<crate::model::EvilString>,
         ) -> Self {
             self.evil_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.evil_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4700
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_evil_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::EvilString>,
                 >,
             >,

↧ Expand context

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

@@ -4877,4740 +4940,4800 @@

↥ Expand context

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

                         crate::constrained::pattern_map_constrained::PatternMapConstrained,
                     >,
                 >,
             >,
         ) -> Self {
             self.map = input.map(|v| v.into());
             self
-4767
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn union(mut self, input: ::std::option::Option<crate::model::PatternUnion>) -> Self {
             self.union = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.union = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-4772
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_union(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::PatternUnion>,
                 >,
             >,

↧ Expand context

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

@@ -5025,4885 +5088,4945 @@

↥ 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")
-4889
+                            )
-4890
+        }
-4891
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedLengthQueryStringInput>
-4894
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-4897
+        }
-4898
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedLengthQueryStringInput {
         type Error = ConstraintViolation;
-4901
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-4904
+        }

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

↧ Expand context

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

@@ -5208,5065 +5396,5235 @@

↥ Expand context

                 crate::input::malformed_length_override_input::String,
             >,
         >,
         pub(crate) min_string: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_length_override_input::MinString,
             >,
         >,
         pub(crate) max_string: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_length_override_input::MaxString,
             >,
         >,
         pub(crate) list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::input::malformed_length_override_input::List,
             >,
         >,
         pub(crate) map: ::std::option::Option<
             crate::constrained::MaybeConstrained<

                 crate::input::malformed_length_override_input::Map,
             >,
         >,
-5088
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn blob(
             mut self,
             input: ::std::option::Option<crate::input::malformed_length_override_input::Blob>,
         ) -> Self {
             self.blob = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.blob = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5097
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_blob(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_length_override_input::Blob,
                     >,
                 >,
             >,
         ) -> Self {
             self.blob = input.map(|v| v.into());
             self
-5111
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn string(
             mut self,
             input: ::std::option::Option<crate::input::malformed_length_override_input::String>,
         ) -> Self {
             self.string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5119
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_length_override_input::String,
                     >,
                 >,
             >,
         ) -> Self {
             self.string = input.map(|v| v.into());
             self
-5133
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_string(
             mut self,
             input: ::std::option::Option<crate::input::malformed_length_override_input::MinString>,
         ) -> Self {
             self.min_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5141
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_length_override_input::MinString,
                     >,
                 >,
             >,
         ) -> Self {
             self.min_string = input.map(|v| v.into());
             self
-5155
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_string(
             mut self,
             input: ::std::option::Option<crate::input::malformed_length_override_input::MaxString>,
         ) -> Self {
             self.max_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5163
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_length_override_input::MaxString,
                     >,
                 >,
             >,
         ) -> Self {
             self.max_string = input.map(|v| v.into());
             self
-5177
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list(
             mut self,
             input: ::std::option::Option<crate::input::malformed_length_override_input::List>,
         ) -> Self {
             self.list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5185
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_length_override_input::List,
                     >,
                 >,
             >,
         ) -> Self {
             self.list = input.map(|v| v.into());
             self
-5199
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map(
             mut self,
             input: ::std::option::Option<crate::input::malformed_length_override_input::Map>,
         ) -> Self {
             self.map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-5207
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<
                         crate::input::malformed_length_override_input::Map,
                     >,

↧ Expand context

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

@@ -6310,6149 +6479,6300 @@

↥ Expand context

-6149
+        }
-6150
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedLengthInput {
         type Error = ConstraintViolation;
-6153
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-6156
+        }
-6157
+    }
     /// A builder for [`MalformedLengthInput`](crate::input::MalformedLengthInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) blob:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthBlob>>,
         pub(crate) string:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthString>>,
         pub(crate) min_string: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::MinLengthString>,
         >,
         pub(crate) max_string: ::std::option::Option<

             crate::constrained::MaybeConstrained<crate::model::MaxLengthString>,
         >,
         pub(crate) list:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthList>>,
         pub(crate) map:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::LengthMap>>,
-6175
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn blob(mut self, input: ::std::option::Option<crate::model::LengthBlob>) -> Self {
             self.blob = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.blob = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6181
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_blob(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthBlob>,
                 >,
             >,
         ) -> Self {
             self.blob = input.map(|v| v.into());
             self
-6193
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn string(mut self, input: ::std::option::Option<crate::model::LengthString>) -> Self {
             self.string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6198
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthString>,
                 >,
             >,
         ) -> Self {
             self.string = input.map(|v| v.into());
             self
-6210
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn min_string(
             mut self,
             input: ::std::option::Option<crate::model::MinLengthString>,
         ) -> Self {
             self.min_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.min_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6218
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_min_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MinLengthString>,
                 >,
             >,
         ) -> Self {
             self.min_string = input.map(|v| v.into());
             self
-6230
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_string(
             mut self,
             input: ::std::option::Option<crate::model::MaxLengthString>,
         ) -> Self {
             self.max_string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.max_string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6238
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::MaxLengthString>,
                 >,
             >,
         ) -> Self {
             self.max_string = input.map(|v| v.into());
             self
-6250
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn list(mut self, input: ::std::option::Option<crate::model::LengthList>) -> Self {
             self.list = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.list = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6255
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::LengthList>,
                 >,
             >,
         ) -> Self {
             self.list = input.map(|v| v.into());
             self
-6267
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map(mut self, input: ::std::option::Option<crate::model::LengthMap>) -> Self {
             self.map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.map = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6272
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::LengthMap>>,
             >,
         ) -> Self {
             self.map = input.map(|v| v.into());

↧ Expand context

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

@@ -6613,6434 +6699,6515 @@

↥ Expand context

         type Error = ConstraintViolation;
-6435
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-6438
+        }
-6439
+    }
     /// A builder for [`MalformedEnumInput`](crate::input::MalformedEnumInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) string:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::EnumString>>,
         pub(crate) string_with_enum_trait: ::std::option::Option<
             crate::constrained::MaybeConstrained<crate::model::EnumTraitString>,
         >,
         pub(crate) list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::enum_list_constrained::EnumListConstrained,
             >,
         >,
         pub(crate) map: ::std::option::Option<

             crate::constrained::MaybeConstrained<
                 crate::constrained::enum_map_constrained::EnumMapConstrained,
             >,
         >,
         pub(crate) union:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::EnumUnion>>,
-6460
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn string(mut self, input: ::std::option::Option<crate::model::EnumString>) -> Self {
             self.string = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6466
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::EnumString>,
                 >,
             >,
         ) -> Self {
             self.string = input.map(|v| v.into());
             self
-6478
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn string_with_enum_trait(
             mut self,
             input: ::std::option::Option<crate::model::EnumTraitString>,
         ) -> Self {
             self.string_with_enum_trait = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.string_with_enum_trait =
                 input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6487
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_string_with_enum_trait(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::EnumTraitString>,
                 >,
             >,

↧ Expand context

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

@@ -6708,6524 +6771,6584 @@

↥ Expand context

-6524
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn map(
             mut self,
             input: ::std::option::Option<
                 ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
             >,
         ) -> Self {
             self.map = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained((v).into()),
             );
             self
-6537
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_map(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<

                         crate::constrained::enum_map_constrained::EnumMapConstrained,
                     >,
                 >,
             >,
         ) -> Self {
             self.map = input.map(|v| v.into());
             self
-6551
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn union(mut self, input: ::std::option::Option<crate::model::EnumUnion>) -> Self {
             self.union = input.map(
                 #[allow(clippy::redundant_closure)]
                 |v| crate::constrained::MaybeConstrained::Constrained(v),
             );
             self.union = input.map(crate::constrained::MaybeConstrained::Constrained);
             self
-6556
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_union(
             mut self,
             input: Option<
                 impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::EnumUnion>>,
             >,
         ) -> Self {
             self.union = input.map(|v| v.into());

↧ Expand context

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

         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>,
-709
+    }
     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
-715
+        }
         #[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());

             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>>,
         pub(crate) blob_list: ::std::option::Option<::std::vec::Vec<::aws_smithy_types::Blob>>,
-1455
+    }
     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
-1464
+        }

         pub(crate) fn set_zero_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
             self.zero_float = Some(input.into());
             self
-1084
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-1089
+        }
         #[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
-1094
+        }
         /// 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()

-1101
+        }
         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_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"

                             .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),
             })

Server Test

Files changed:

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

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

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

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

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

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

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

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

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

         pub(crate) list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         pub(crate) map:
             ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
         pub(crate) union: ::std::option::Option<crate::model::SimpleUnion>,
         pub(crate) unit_union: ::std::option::Option<crate::model::UnitUnion>,
         pub(crate) structure_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::struct_list_constrained::StructListConstrained,
             >,
         >,
         pub(crate) complex_list: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::complex_list_constrained::ComplexListConstrained,
             >,
         >,
         pub(crate) complex_map: ::std::option::Option<
             crate::constrained::MaybeConstrained<
                 crate::constrained::complex_map_constrained::ComplexMapConstrained,
             >,
         >,

             self
-1148
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn double(mut self, input: ::std::option::Option<f64>) -> Self {
             self.double = input;
             self
-1153
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_double(mut self, input: Option<impl ::std::convert::Into<f64>>) -> Self {
             self.double = input.map(|v| v.into());
             self
-1158
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn timestamp(
             mut self,
             input: ::std::option::Option<::aws_smithy_types::DateTime>,
         ) -> Self {
             self.timestamp = input;
             self
-1166
+        }

             self
-1189
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn required_blob(mut self, input: ::aws_smithy_types::Blob) -> Self {
             self.required_blob = Some(input);
             self
-1194
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_required_blob(
             mut self,
             input: impl ::std::convert::Into<::aws_smithy_types::Blob>,
         ) -> Self {
             self.required_blob = Some(input.into());
             self
-1202
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn required_boolean(mut self, input: bool) -> Self {
             self.required_boolean = Some(input);
             self
-1207
+        }

         pub fn bucket(mut self, input: ::std::string::String) -> Self {
             self.bucket = Some(input);
             self
-686
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_bucket(
             mut self,
             input: impl ::std::convert::Into<::std::string::String>,
         ) -> Self {
             self.bucket = Some(input.into());
             self
-694
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.delimiter = input;
             self
-699
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_delimiter(
             mut self,

         ) -> Self {
             self.encoding_type = input.map(|v| v.into());
             self
-727
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn max_keys(mut self, input: ::std::option::Option<i32>) -> Self {
             self.max_keys = input;
             self
-732
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_max_keys(
             mut self,
             input: Option<impl ::std::convert::Into<i32>>,
         ) -> Self {
             self.max_keys = input.map(|v| v.into());
             self
-740
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn prefix(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.prefix = input;

         pub fn fetch_owner(mut self, input: ::std::option::Option<bool>) -> Self {
             self.fetch_owner = input;
             self
-774
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_fetch_owner(
             mut self,
             input: Option<impl ::std::convert::Into<bool>>,
         ) -> Self {
             self.fetch_owner = input.map(|v| v.into());
             self
-782
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn start_after(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.start_after = input;
             self
-787
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_start_after(
             mut self,