Server Test

Server Test

rev. d838bf488731ae5e751cce0fe13f339a5b9be858

Files changed:

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

@@ -1,1 +188,187 @@
    7      7   
    8      8   
impl From<crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained>
    9      9   
    for crate::constrained::MaybeConstrained<crate::model::ComplexUnion>
   10     10   
{
   11     11   
    fn from(
   12     12   
        value: crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained,
   13     13   
    ) -> Self {
   14     14   
        Self::Unconstrained(value)
   15     15   
    }
   16     16   
}
   17         -
   18         -
pub(crate) mod complex_union_unconstrained {
   19         -
   20         -
    #[allow(clippy::enum_variant_names)]
   21         -
    #[derive(Debug, Clone)]
   22         -
    pub(crate) enum ComplexUnionUnconstrained {
   23         -
        ComplexStruct(crate::model::complex_struct::Builder),
   24         -
        List(::std::vec::Vec<::std::string::String>),
   25         -
        Map(::std::collections::HashMap<::std::string::String, i32>),
   26         -
        Structure(crate::model::simple_struct::Builder),
   27         -
        Union(crate::model::SimpleUnion),
   28         -
    }
   29         -
    impl ::std::convert::TryFrom<ComplexUnionUnconstrained> for crate::model::ComplexUnion {
   30         -
        type Error = crate::model::complex_union::ConstraintViolation;
   31         -
   32         -
        fn try_from(value: ComplexUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
   33         -
            Ok(
   34         -
        match value {
   35         -
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::ComplexStruct(unconstrained) => Self::ComplexStruct(
   36         -
                unconstrained
   37         -
                                        .try_into()
   38         -
                                        
   39         -
                                        
   40         -
                                        .map_err(Self::Error::ComplexStruct)?
   41         -
            ),
   42         -
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::List(unconstrained) => Self::List(
   43         -
                unconstrained
   44         -
            ),
   45         -
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Map(unconstrained) => Self::Map(
   46         -
                unconstrained
   47         -
            ),
   48         -
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Structure(unconstrained) => Self::Structure(
   49         -
                unconstrained
   50         -
                                        .try_into()
   51         -
                                        
   52         -
                                        
   53         -
                                        .map_err(Self::Error::Structure)?
   54         -
            ),
   55         -
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Union(unconstrained) => Self::Union(
   56         -
                unconstrained
   57         -
            ),
   58         -
        }
   59         -
    )
   60         -
        }
   61         -
    }
   62         -
}
   63         -
pub(crate) mod complex_map_unconstrained {
          17  +
pub(crate) mod struct_list_unconstrained {
   64     18   
   65     19   
    #[derive(Debug, Clone)]
   66         -
    pub(crate) struct ComplexMapUnconstrained(
   67         -
        pub(crate)  std::collections::HashMap<
   68         -
            ::std::string::String,
   69         -
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained,
   70         -
        >,
          20  +
    pub(crate) struct StructListUnconstrained(
          21  +
        pub(crate) std::vec::Vec<crate::model::simple_struct::Builder>,
   71     22   
    );
   72     23   
   73         -
    impl From<ComplexMapUnconstrained>
          24  +
    impl From<StructListUnconstrained>
   74     25   
        for crate::constrained::MaybeConstrained<
   75         -
            crate::constrained::complex_map_constrained::ComplexMapConstrained,
          26  +
            crate::constrained::struct_list_constrained::StructListConstrained,
   76     27   
        >
   77     28   
    {
   78         -
        fn from(value: ComplexMapUnconstrained) -> Self {
          29  +
        fn from(value: StructListUnconstrained) -> Self {
   79     30   
            Self::Unconstrained(value)
   80     31   
        }
   81     32   
    }
   82         -
    impl std::convert::TryFrom<ComplexMapUnconstrained>
   83         -
        for crate::constrained::complex_map_constrained::ComplexMapConstrained
          33  +
    impl std::convert::TryFrom<StructListUnconstrained>
          34  +
        for crate::constrained::struct_list_constrained::StructListConstrained
   84     35   
    {
   85         -
        type Error = crate::model::complex_map::ConstraintViolation;
   86         -
        fn try_from(value: ComplexMapUnconstrained) -> std::result::Result<Self, Self::Error> {
          36  +
        type Error = crate::model::struct_list::ConstraintViolation;
          37  +
        fn try_from(value: StructListUnconstrained) -> std::result::Result<Self, Self::Error> {
   87     38   
            let res: ::std::result::Result<
   88         -
                ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
   89         -
                Self::Error,
          39  +
                ::std::vec::Vec<crate::model::SimpleStruct>,
          40  +
                (usize, crate::model::simple_struct::ConstraintViolation),
   90     41   
            > = value
   91     42   
                .0
   92     43   
                .into_iter()
   93         -
                .map(
   94         -
                    |(k, v)| match crate::model::ComplexUnion::try_from(v).map_err(Box::new) {
   95         -
                        Ok(v) => Ok((k, v)),
   96         -
                        Err(inner_constraint_violation) => {
   97         -
                            Err(Self::Error::Value(k, inner_constraint_violation))
   98         -
                        }
   99         -
                    },
  100         -
                )
          44  +
                .enumerate()
          45  +
                .map(|(idx, inner)| {
          46  +
                    inner
          47  +
                        .try_into()
          48  +
                        .map_err(|inner_violation| (idx, inner_violation))
          49  +
                })
  101     50   
                .collect();
  102         -
            let hm = res?;
  103         -
            Ok(Self(hm))
          51  +
            let inner =
          52  +
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
          53  +
            Ok(Self(inner))
  104     54   
        }
  105     55   
    }
  106     56   
}
  107     57   
pub(crate) mod complex_list_unconstrained {
  108     58   
  109     59   
    #[derive(Debug, Clone)]
  110     60   
    pub(crate) struct ComplexListUnconstrained(
  111     61   
        pub(crate) 
  112     62   
            std::vec::Vec<crate::unconstrained::complex_map_unconstrained::ComplexMapUnconstrained>,
  113     63   
    );
  114     64   
  115     65   
    impl From<ComplexListUnconstrained>
  116     66   
        for crate::constrained::MaybeConstrained<
  117     67   
            crate::constrained::complex_list_constrained::ComplexListConstrained,
  118     68   
        >
  119     69   
    {
  120     70   
        fn from(value: ComplexListUnconstrained) -> Self {
  121     71   
            Self::Unconstrained(value)
  122     72   
        }
  123     73   
    }
  124     74   
    impl std::convert::TryFrom<ComplexListUnconstrained>
  125     75   
        for crate::constrained::complex_list_constrained::ComplexListConstrained
  126     76   
    {
  127     77   
        type Error = crate::model::complex_list::ConstraintViolation;
  128     78   
        fn try_from(value: ComplexListUnconstrained) -> std::result::Result<Self, Self::Error> {
  129     79   
            let res: ::std::result::Result<
  130     80   
                ::std::vec::Vec<crate::constrained::complex_map_constrained::ComplexMapConstrained>,
  131     81   
                (usize, crate::model::complex_map::ConstraintViolation),
  132     82   
            > = value
  133     83   
                .0
  134     84   
                .into_iter()
  135     85   
                .enumerate()
  136     86   
                .map(|(idx, inner)| {
  137     87   
                    inner
  138     88   
                        .try_into()
  139     89   
                        .map_err(|inner_violation| (idx, inner_violation))
  140     90   
                })
  141     91   
                .collect();
  142     92   
            let inner = res
  143     93   
                .map_err(|(idx, inner_violation)| (idx, Box::new(inner_violation)))
  144     94   
                .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
  145     95   
            Ok(Self(inner))
  146     96   
        }
  147     97   
    }
  148     98   
}
  149         -
pub(crate) mod struct_list_unconstrained {
          99  +
pub(crate) mod complex_map_unconstrained {
  150    100   
  151    101   
    #[derive(Debug, Clone)]
  152         -
    pub(crate) struct StructListUnconstrained(
  153         -
        pub(crate) std::vec::Vec<crate::model::simple_struct::Builder>,
         102  +
    pub(crate) struct ComplexMapUnconstrained(
         103  +
        pub(crate)  std::collections::HashMap<
         104  +
            ::std::string::String,
         105  +
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained,
         106  +
        >,
  154    107   
    );
  155    108   
  156         -
    impl From<StructListUnconstrained>
         109  +
    impl From<ComplexMapUnconstrained>
  157    110   
        for crate::constrained::MaybeConstrained<
  158         -
            crate::constrained::struct_list_constrained::StructListConstrained,
         111  +
            crate::constrained::complex_map_constrained::ComplexMapConstrained,
  159    112   
        >
  160    113   
    {
  161         -
        fn from(value: StructListUnconstrained) -> Self {
         114  +
        fn from(value: ComplexMapUnconstrained) -> Self {
  162    115   
            Self::Unconstrained(value)
  163    116   
        }
  164    117   
    }
  165         -
    impl std::convert::TryFrom<StructListUnconstrained>
  166         -
        for crate::constrained::struct_list_constrained::StructListConstrained
         118  +
    impl std::convert::TryFrom<ComplexMapUnconstrained>
         119  +
        for crate::constrained::complex_map_constrained::ComplexMapConstrained
  167    120   
    {
  168         -
        type Error = crate::model::struct_list::ConstraintViolation;
  169         -
        fn try_from(value: StructListUnconstrained) -> std::result::Result<Self, Self::Error> {
         121  +
        type Error = crate::model::complex_map::ConstraintViolation;
         122  +
        fn try_from(value: ComplexMapUnconstrained) -> std::result::Result<Self, Self::Error> {
  170    123   
            let res: ::std::result::Result<
  171         -
                ::std::vec::Vec<crate::model::SimpleStruct>,
  172         -
                (usize, crate::model::simple_struct::ConstraintViolation),
         124  +
                ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
         125  +
                Self::Error,
  173    126   
            > = value
  174    127   
                .0
  175    128   
                .into_iter()
  176         -
                .enumerate()
  177         -
                .map(|(idx, inner)| {
  178         -
                    inner
  179         -
                        .try_into()
  180         -
                        .map_err(|inner_violation| (idx, inner_violation))
  181         -
                })
         129  +
                .map(
         130  +
                    |(k, v)| match crate::model::ComplexUnion::try_from(v).map_err(Box::new) {
         131  +
                        Ok(v) => Ok((k, v)),
         132  +
                        Err(inner_constraint_violation) => {
         133  +
                            Err(Self::Error::Value(k, inner_constraint_violation))
         134  +
                        }
         135  +
                    },
         136  +
                )
  182    137   
                .collect();
  183         -
            let inner =
  184         -
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
  185         -
            Ok(Self(inner))
         138  +
            let hm = res?;
         139  +
            Ok(Self(hm))
         140  +
        }
         141  +
    }
         142  +
}
         143  +
pub(crate) mod complex_union_unconstrained {
         144  +
         145  +
    #[allow(clippy::enum_variant_names)]
         146  +
    #[derive(Debug, Clone)]
         147  +
    pub(crate) enum ComplexUnionUnconstrained {
         148  +
        ComplexStruct(crate::model::complex_struct::Builder),
         149  +
        List(::std::vec::Vec<::std::string::String>),
         150  +
        Map(::std::collections::HashMap<::std::string::String, i32>),
         151  +
        Structure(crate::model::simple_struct::Builder),
         152  +
        Union(crate::model::SimpleUnion),
         153  +
    }
         154  +
    impl ::std::convert::TryFrom<ComplexUnionUnconstrained> for crate::model::ComplexUnion {
         155  +
        type Error = crate::model::complex_union::ConstraintViolation;
         156  +
         157  +
        fn try_from(value: ComplexUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
         158  +
            Ok(
         159  +
        match value {
         160  +
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::ComplexStruct(unconstrained) => Self::ComplexStruct(
         161  +
                unconstrained
         162  +
                                        .try_into()
         163  +
                                        
         164  +
                                        
         165  +
                                        .map_err(Self::Error::ComplexStruct)?
         166  +
            ),
         167  +
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::List(unconstrained) => Self::List(
         168  +
                unconstrained
         169  +
            ),
         170  +
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Map(unconstrained) => Self::Map(
         171  +
                unconstrained
         172  +
            ),
         173  +
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Structure(unconstrained) => Self::Structure(
         174  +
                unconstrained
         175  +
                                        .try_into()
         176  +
                                        
         177  +
                                        
         178  +
                                        .map_err(Self::Error::Structure)?
         179  +
            ),
         180  +
            crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Union(unconstrained) => Self::Union(
         181  +
                unconstrained
         182  +
            ),
         183  +
        }
         184  +
    )
  186    185   
        }
  187    186   
    }
  188    187   
}

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

@@ -1,1 +107,107 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3         -
pub(crate) mod complex_map_constrained {
           3  +
pub(crate) mod struct_list_constrained {
    4      4   
    5      5   
    #[derive(Debug, Clone)]
    6         -
    pub(crate) struct ComplexMapConstrained(
    7         -
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
    8         -
    );
           6  +
    pub(crate) struct StructListConstrained(pub(crate) std::vec::Vec<crate::model::SimpleStruct>);
    9      7   
   10         -
    impl crate::constrained::Constrained for ComplexMapConstrained {
           8  +
    impl crate::constrained::Constrained for StructListConstrained {
   11      9   
        type Unconstrained =
   12         -
            crate::unconstrained::complex_map_unconstrained::ComplexMapUnconstrained;
          10  +
            crate::unconstrained::struct_list_unconstrained::StructListUnconstrained;
   13     11   
    }
   14         -
    impl
   15         -
        ::std::convert::From<
   16         -
            ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
   17         -
        > for ComplexMapConstrained
   18         -
    {
   19         -
        fn from(
   20         -
            v: ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
   21         -
        ) -> Self {
          12  +
    impl ::std::convert::From<::std::vec::Vec<crate::model::SimpleStruct>> for StructListConstrained {
          13  +
        fn from(v: ::std::vec::Vec<crate::model::SimpleStruct>) -> Self {
   22     14   
            Self(v)
   23     15   
        }
   24     16   
    }
   25     17   
   26         -
    impl ::std::convert::From<ComplexMapConstrained>
   27         -
        for ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>
   28         -
    {
   29         -
        fn from(v: ComplexMapConstrained) -> Self {
          18  +
    impl ::std::convert::From<StructListConstrained> for ::std::vec::Vec<crate::model::SimpleStruct> {
          19  +
        fn from(v: StructListConstrained) -> Self {
   30     20   
            v.0
   31     21   
        }
   32     22   
    }
   33     23   
}
   34     24   
pub(crate) mod complex_list_constrained {
   35     25   
   36     26   
    #[derive(Debug, Clone)]
   37     27   
    pub(crate) struct ComplexListConstrained(
   38     28   
        pub(crate) std::vec::Vec<crate::constrained::complex_map_constrained::ComplexMapConstrained>,
   39     29   
    );
   40     30   
   41     31   
    impl crate::constrained::Constrained for ComplexListConstrained {
   42     32   
        type Unconstrained =
   43     33   
            crate::unconstrained::complex_list_unconstrained::ComplexListUnconstrained;
   44     34   
    }
   45     35   
    impl
   46     36   
        ::std::convert::From<
   47     37   
            ::std::vec::Vec<
   48     38   
                ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
   49     39   
            >,
   50     40   
        > for ComplexListConstrained
   51     41   
    {
   52     42   
        fn from(
   53     43   
            v: ::std::vec::Vec<
   54     44   
                ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
   55     45   
            >,
   56     46   
        ) -> Self {
   57     47   
            Self(v.into_iter().map(|item| item.into()).collect())
   58     48   
        }
   59     49   
    }
   60     50   
   61     51   
    impl ::std::convert::From<ComplexListConstrained>
   62     52   
        for ::std::vec::Vec<
   63     53   
            ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
   64     54   
        >
   65     55   
    {
   66     56   
        fn from(v: ComplexListConstrained) -> Self {
   67     57   
            v.0.into_iter().map(|item| item.into()).collect()
   68     58   
        }
   69     59   
    }
   70     60   
}
   71         -
pub(crate) mod struct_list_constrained {
          61  +
pub(crate) mod complex_map_constrained {
   72     62   
   73     63   
    #[derive(Debug, Clone)]
   74         -
    pub(crate) struct StructListConstrained(pub(crate) std::vec::Vec<crate::model::SimpleStruct>);
          64  +
    pub(crate) struct ComplexMapConstrained(
          65  +
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
          66  +
    );
   75     67   
   76         -
    impl crate::constrained::Constrained for StructListConstrained {
          68  +
    impl crate::constrained::Constrained for ComplexMapConstrained {
   77     69   
        type Unconstrained =
   78         -
            crate::unconstrained::struct_list_unconstrained::StructListUnconstrained;
          70  +
            crate::unconstrained::complex_map_unconstrained::ComplexMapUnconstrained;
   79     71   
    }
   80         -
    impl ::std::convert::From<::std::vec::Vec<crate::model::SimpleStruct>> for StructListConstrained {
   81         -
        fn from(v: ::std::vec::Vec<crate::model::SimpleStruct>) -> Self {
          72  +
    impl
          73  +
        ::std::convert::From<
          74  +
            ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
          75  +
        > for ComplexMapConstrained
          76  +
    {
          77  +
        fn from(
          78  +
            v: ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
          79  +
        ) -> Self {
   82     80   
            Self(v)
   83     81   
        }
   84     82   
    }
   85     83   
   86         -
    impl ::std::convert::From<StructListConstrained> for ::std::vec::Vec<crate::model::SimpleStruct> {
   87         -
        fn from(v: StructListConstrained) -> Self {
          84  +
    impl ::std::convert::From<ComplexMapConstrained>
          85  +
        for ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>
          86  +
    {
          87  +
        fn from(v: ComplexMapConstrained) -> Self {
   88     88   
            v.0
   89     89   
        }
   90     90   
    }
   91     91   
}
   92     92   
   93     93   
/*
   94     94   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   95     95   
 * SPDX-License-Identifier: Apache-2.0
   96     96   
 */
   97     97

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

@@ -1,1 +389,390 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
/// Error type for the `StreamingOperationWithOptionalData` operation.
    3         -
/// Each variant represents an error that can occur for the `StreamingOperationWithOptionalData` operation.
           2  +
/// Error type for the `SimpleStructOperation` operation.
           3  +
/// Each variant represents an error that can occur for the `SimpleStructOperation` operation.
    4      4   
#[derive(::std::fmt::Debug)]
    5         -
pub enum StreamingOperationWithOptionalDataError {
           5  +
pub enum SimpleStructOperationError {
    6      6   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
    7      7   
    ValidationException(crate::error::ValidationException),
    8      8   
}
    9         -
impl ::std::fmt::Display for StreamingOperationWithOptionalDataError {
           9  +
impl ::std::fmt::Display for SimpleStructOperationError {
   10     10   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   11     11   
        match &self {
   12         -
            StreamingOperationWithOptionalDataError::ValidationException(_inner) => _inner.fmt(f),
          12  +
            SimpleStructOperationError::ValidationException(_inner) => _inner.fmt(f),
   13     13   
        }
   14     14   
    }
   15     15   
}
   16         -
impl StreamingOperationWithOptionalDataError {
   17         -
    /// Returns `true` if the error kind is `StreamingOperationWithOptionalDataError::ValidationException`.
          16  +
impl SimpleStructOperationError {
          17  +
    /// Returns `true` if the error kind is `SimpleStructOperationError::ValidationException`.
   18     18   
    pub fn is_validation_exception(&self) -> bool {
   19         -
        matches!(
   20         -
            &self,
   21         -
            StreamingOperationWithOptionalDataError::ValidationException(_)
   22         -
        )
          19  +
        matches!(&self, SimpleStructOperationError::ValidationException(_))
   23     20   
    }
   24     21   
    /// Returns the error name string by matching the correct variant.
   25     22   
    pub fn name(&self) -> &'static str {
   26     23   
        match &self {
   27         -
            StreamingOperationWithOptionalDataError::ValidationException(_inner) => _inner.name(),
          24  +
            SimpleStructOperationError::ValidationException(_inner) => _inner.name(),
   28     25   
        }
   29     26   
    }
   30     27   
}
   31         -
impl ::std::error::Error for StreamingOperationWithOptionalDataError {
          28  +
impl ::std::error::Error for SimpleStructOperationError {
   32     29   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
   33     30   
        match &self {
   34         -
            StreamingOperationWithOptionalDataError::ValidationException(_inner) => Some(_inner),
          31  +
            SimpleStructOperationError::ValidationException(_inner) => Some(_inner),
   35     32   
        }
   36     33   
    }
   37     34   
}
   38     35   
impl ::std::convert::From<crate::error::ValidationException>
   39         -
    for crate::error::StreamingOperationWithOptionalDataError
          36  +
    for crate::error::SimpleStructOperationError
   40     37   
{
   41     38   
    fn from(
   42     39   
        variant: crate::error::ValidationException,
   43         -
    ) -> crate::error::StreamingOperationWithOptionalDataError {
          40  +
    ) -> crate::error::SimpleStructOperationError {
   44     41   
        Self::ValidationException(variant)
   45     42   
    }
   46     43   
}
   47     44   
   48         -
/// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
   49         -
#[derive(
   50         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
   51         -
)]
   52         -
pub struct ValidationException {
   53         -
    /// A summary of the validation failure.
   54         -
    pub message: ::std::string::String,
   55         -
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
   56         -
    pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
   57         -
}
   58         -
impl ValidationException {
   59         -
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
   60         -
    pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
   61         -
        self.field_list.as_deref()
   62         -
    }
   63         -
}
   64         -
impl ValidationException {
   65         -
    /// Returns the error message.
   66         -
    pub fn message(&self) -> &str {
   67         -
        &self.message
   68         -
    }
   69         -
    #[doc(hidden)]
   70         -
    /// Returns the error name.
   71         -
    pub fn name(&self) -> &'static str {
   72         -
        "ValidationException"
   73         -
    }
   74         -
}
   75         -
impl ::std::fmt::Display for ValidationException {
   76         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   77         -
        ::std::write!(f, "ValidationException")?;
   78         -
        {
   79         -
            ::std::write!(f, ": {}", &self.message)?;
   80         -
        }
   81         -
        Ok(())
   82         -
    }
   83         -
}
   84         -
impl ::std::error::Error for ValidationException {}
   85         -
impl ValidationException {
   86         -
    /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
   87         -
    pub fn builder() -> crate::error::validation_exception::Builder {
   88         -
        crate::error::validation_exception::Builder::default()
   89         -
    }
   90         -
}
   91         -
   92         -
/// Error type for the `StreamingOperationWithInitialResponse` operation.
   93         -
/// Each variant represents an error that can occur for the `StreamingOperationWithInitialResponse` operation.
          45  +
/// Error type for the `ErrorSerializationOperation` operation.
          46  +
/// Each variant represents an error that can occur for the `ErrorSerializationOperation` operation.
   94     47   
#[derive(::std::fmt::Debug)]
   95         -
pub enum StreamingOperationWithInitialResponseError {
          48  +
pub enum ErrorSerializationOperationError {
   96     49   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
   97     50   
    ValidationException(crate::error::ValidationException),
   98     51   
}
   99         -
impl ::std::fmt::Display for StreamingOperationWithInitialResponseError {
          52  +
impl ::std::fmt::Display for ErrorSerializationOperationError {
  100     53   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  101     54   
        match &self {
  102         -
            StreamingOperationWithInitialResponseError::ValidationException(_inner) => {
  103         -
                _inner.fmt(f)
  104         -
            }
          55  +
            ErrorSerializationOperationError::ValidationException(_inner) => _inner.fmt(f),
  105     56   
        }
  106     57   
    }
  107     58   
}
  108         -
impl StreamingOperationWithInitialResponseError {
  109         -
    /// Returns `true` if the error kind is `StreamingOperationWithInitialResponseError::ValidationException`.
          59  +
impl ErrorSerializationOperationError {
          60  +
    /// Returns `true` if the error kind is `ErrorSerializationOperationError::ValidationException`.
  110     61   
    pub fn is_validation_exception(&self) -> bool {
  111     62   
        matches!(
  112     63   
            &self,
  113         -
            StreamingOperationWithInitialResponseError::ValidationException(_)
          64  +
            ErrorSerializationOperationError::ValidationException(_)
  114     65   
        )
  115     66   
    }
  116     67   
    /// Returns the error name string by matching the correct variant.
  117     68   
    pub fn name(&self) -> &'static str {
  118     69   
        match &self {
  119         -
            StreamingOperationWithInitialResponseError::ValidationException(_inner) => {
  120         -
                _inner.name()
  121         -
            }
          70  +
            ErrorSerializationOperationError::ValidationException(_inner) => _inner.name(),
  122     71   
        }
  123     72   
    }
  124     73   
}
  125         -
impl ::std::error::Error for StreamingOperationWithInitialResponseError {
          74  +
impl ::std::error::Error for ErrorSerializationOperationError {
  126     75   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  127     76   
        match &self {
  128         -
            StreamingOperationWithInitialResponseError::ValidationException(_inner) => Some(_inner),
          77  +
            ErrorSerializationOperationError::ValidationException(_inner) => Some(_inner),
  129     78   
        }
  130     79   
    }
  131     80   
}
  132     81   
impl ::std::convert::From<crate::error::ValidationException>
  133         -
    for crate::error::StreamingOperationWithInitialResponseError
          82  +
    for crate::error::ErrorSerializationOperationError
  134     83   
{
  135     84   
    fn from(
  136     85   
        variant: crate::error::ValidationException,
  137         -
    ) -> crate::error::StreamingOperationWithInitialResponseError {
          86  +
    ) -> crate::error::ErrorSerializationOperationError {
  138     87   
        Self::ValidationException(variant)
  139     88   
    }
  140     89   
}
  141     90   
  142         -
/// Error type for the `StreamingOperationWithInitialData` operation.
  143         -
/// Each variant represents an error that can occur for the `StreamingOperationWithInitialData` operation.
          91  +
/// Error type for the `ComplexStructOperation` operation.
          92  +
/// Each variant represents an error that can occur for the `ComplexStructOperation` operation.
  144     93   
#[derive(::std::fmt::Debug)]
  145         -
pub enum StreamingOperationWithInitialDataError {
          94  +
pub enum ComplexStructOperationError {
  146     95   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  147     96   
    ValidationException(crate::error::ValidationException),
  148     97   
}
  149         -
impl ::std::fmt::Display for StreamingOperationWithInitialDataError {
          98  +
impl ::std::fmt::Display for ComplexStructOperationError {
  150     99   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  151    100   
        match &self {
  152         -
            StreamingOperationWithInitialDataError::ValidationException(_inner) => _inner.fmt(f),
         101  +
            ComplexStructOperationError::ValidationException(_inner) => _inner.fmt(f),
  153    102   
        }
  154    103   
    }
  155    104   
}
  156         -
impl StreamingOperationWithInitialDataError {
  157         -
    /// Returns `true` if the error kind is `StreamingOperationWithInitialDataError::ValidationException`.
         105  +
impl ComplexStructOperationError {
         106  +
    /// Returns `true` if the error kind is `ComplexStructOperationError::ValidationException`.
  158    107   
    pub fn is_validation_exception(&self) -> bool {
  159         -
        matches!(
  160         -
            &self,
  161         -
            StreamingOperationWithInitialDataError::ValidationException(_)
  162         -
        )
         108  +
        matches!(&self, ComplexStructOperationError::ValidationException(_))
  163    109   
    }
  164    110   
    /// Returns the error name string by matching the correct variant.
  165    111   
    pub fn name(&self) -> &'static str {
  166    112   
        match &self {
  167         -
            StreamingOperationWithInitialDataError::ValidationException(_inner) => _inner.name(),
         113  +
            ComplexStructOperationError::ValidationException(_inner) => _inner.name(),
  168    114   
        }
  169    115   
    }
  170    116   
}
  171         -
impl ::std::error::Error for StreamingOperationWithInitialDataError {
         117  +
impl ::std::error::Error for ComplexStructOperationError {
  172    118   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  173    119   
        match &self {
  174         -
            StreamingOperationWithInitialDataError::ValidationException(_inner) => Some(_inner),
         120  +
            ComplexStructOperationError::ValidationException(_inner) => Some(_inner),
  175    121   
        }
  176    122   
    }
  177    123   
}
  178    124   
impl ::std::convert::From<crate::error::ValidationException>
  179         -
    for crate::error::StreamingOperationWithInitialDataError
         125  +
    for crate::error::ComplexStructOperationError
  180    126   
{
  181    127   
    fn from(
  182    128   
        variant: crate::error::ValidationException,
  183         -
    ) -> crate::error::StreamingOperationWithInitialDataError {
         129  +
    ) -> crate::error::ComplexStructOperationError {
  184    130   
        Self::ValidationException(variant)
  185    131   
    }
  186    132   
}
  187    133   
  188    134   
/// Error type for the `StreamingOperation` operation.
  189    135   
/// Each variant represents an error that can occur for the `StreamingOperation` operation.
  190    136   
#[derive(::std::fmt::Debug)]
  191    137   
pub enum StreamingOperationError {
  192    138   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  193    139   
    ValidationException(crate::error::ValidationException),
  194    140   
}
  195    141   
impl ::std::fmt::Display for StreamingOperationError {
  196    142   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  197    143   
        match &self {
  198    144   
            StreamingOperationError::ValidationException(_inner) => _inner.fmt(f),
  199    145   
        }
  200    146   
    }
  201    147   
}
  202    148   
impl StreamingOperationError {
  203    149   
    /// Returns `true` if the error kind is `StreamingOperationError::ValidationException`.
  204    150   
    pub fn is_validation_exception(&self) -> bool {
  205    151   
        matches!(&self, StreamingOperationError::ValidationException(_))
  206    152   
    }
  207    153   
    /// Returns the error name string by matching the correct variant.
  208    154   
    pub fn name(&self) -> &'static str {
  209    155   
        match &self {
  210    156   
            StreamingOperationError::ValidationException(_inner) => _inner.name(),
  211    157   
        }
  212    158   
    }
  213    159   
}
  214    160   
impl ::std::error::Error for StreamingOperationError {
  215    161   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  216    162   
        match &self {
  217    163   
            StreamingOperationError::ValidationException(_inner) => Some(_inner),
  218    164   
        }
  219    165   
    }
  220    166   
}
  221    167   
impl ::std::convert::From<crate::error::ValidationException>
  222    168   
    for crate::error::StreamingOperationError
  223    169   
{
  224    170   
    fn from(variant: crate::error::ValidationException) -> crate::error::StreamingOperationError {
  225    171   
        Self::ValidationException(variant)
  226    172   
    }
  227    173   
}
  228    174   
  229         -
/// Error type for the `ComplexStructOperation` operation.
  230         -
/// Each variant represents an error that can occur for the `ComplexStructOperation` operation.
         175  +
/// Error type for the `StreamingOperationWithInitialData` operation.
         176  +
/// Each variant represents an error that can occur for the `StreamingOperationWithInitialData` operation.
  231    177   
#[derive(::std::fmt::Debug)]
  232         -
pub enum ComplexStructOperationError {
         178  +
pub enum StreamingOperationWithInitialDataError {
  233    179   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  234    180   
    ValidationException(crate::error::ValidationException),
  235    181   
}
  236         -
impl ::std::fmt::Display for ComplexStructOperationError {
         182  +
impl ::std::fmt::Display for StreamingOperationWithInitialDataError {
  237    183   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  238    184   
        match &self {
  239         -
            ComplexStructOperationError::ValidationException(_inner) => _inner.fmt(f),
         185  +
            StreamingOperationWithInitialDataError::ValidationException(_inner) => _inner.fmt(f),
  240    186   
        }
  241    187   
    }
  242    188   
}
  243         -
impl ComplexStructOperationError {
  244         -
    /// Returns `true` if the error kind is `ComplexStructOperationError::ValidationException`.
         189  +
impl StreamingOperationWithInitialDataError {
         190  +
    /// Returns `true` if the error kind is `StreamingOperationWithInitialDataError::ValidationException`.
  245    191   
    pub fn is_validation_exception(&self) -> bool {
  246         -
        matches!(&self, ComplexStructOperationError::ValidationException(_))
         192  +
        matches!(
         193  +
            &self,
         194  +
            StreamingOperationWithInitialDataError::ValidationException(_)
         195  +
        )
  247    196   
    }
  248    197   
    /// Returns the error name string by matching the correct variant.
  249    198   
    pub fn name(&self) -> &'static str {
  250    199   
        match &self {
  251         -
            ComplexStructOperationError::ValidationException(_inner) => _inner.name(),
         200  +
            StreamingOperationWithInitialDataError::ValidationException(_inner) => _inner.name(),
  252    201   
        }
  253    202   
    }
  254    203   
}
  255         -
impl ::std::error::Error for ComplexStructOperationError {
         204  +
impl ::std::error::Error for StreamingOperationWithInitialDataError {
  256    205   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  257    206   
        match &self {
  258         -
            ComplexStructOperationError::ValidationException(_inner) => Some(_inner),
         207  +
            StreamingOperationWithInitialDataError::ValidationException(_inner) => Some(_inner),
  259    208   
        }
  260    209   
    }
  261    210   
}
  262    211   
impl ::std::convert::From<crate::error::ValidationException>
  263         -
    for crate::error::ComplexStructOperationError
         212  +
    for crate::error::StreamingOperationWithInitialDataError
  264    213   
{
  265    214   
    fn from(
  266    215   
        variant: crate::error::ValidationException,
  267         -
    ) -> crate::error::ComplexStructOperationError {
         216  +
    ) -> crate::error::StreamingOperationWithInitialDataError {
  268    217   
        Self::ValidationException(variant)
  269    218   
    }
  270    219   
}
  271    220   
  272         -
/// Error type for the `ErrorSerializationOperation` operation.
  273         -
/// Each variant represents an error that can occur for the `ErrorSerializationOperation` operation.
         221  +
/// Error type for the `StreamingOperationWithInitialResponse` operation.
         222  +
/// Each variant represents an error that can occur for the `StreamingOperationWithInitialResponse` operation.
  274    223   
#[derive(::std::fmt::Debug)]
  275         -
pub enum ErrorSerializationOperationError {
         224  +
pub enum StreamingOperationWithInitialResponseError {
  276    225   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  277    226   
    ValidationException(crate::error::ValidationException),
  278    227   
}
  279         -
impl ::std::fmt::Display for ErrorSerializationOperationError {
         228  +
impl ::std::fmt::Display for StreamingOperationWithInitialResponseError {
  280    229   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  281    230   
        match &self {
  282         -
            ErrorSerializationOperationError::ValidationException(_inner) => _inner.fmt(f),
         231  +
            StreamingOperationWithInitialResponseError::ValidationException(_inner) => {
         232  +
                _inner.fmt(f)
         233  +
            }
  283    234   
        }
  284    235   
    }
  285    236   
}
  286         -
impl ErrorSerializationOperationError {
  287         -
    /// Returns `true` if the error kind is `ErrorSerializationOperationError::ValidationException`.
         237  +
impl StreamingOperationWithInitialResponseError {
         238  +
    /// Returns `true` if the error kind is `StreamingOperationWithInitialResponseError::ValidationException`.
  288    239   
    pub fn is_validation_exception(&self) -> bool {
  289    240   
        matches!(
  290    241   
            &self,
  291         -
            ErrorSerializationOperationError::ValidationException(_)
         242  +
            StreamingOperationWithInitialResponseError::ValidationException(_)
  292    243   
        )
  293    244   
    }
  294    245   
    /// Returns the error name string by matching the correct variant.
  295    246   
    pub fn name(&self) -> &'static str {
  296    247   
        match &self {
  297         -
            ErrorSerializationOperationError::ValidationException(_inner) => _inner.name(),
         248  +
            StreamingOperationWithInitialResponseError::ValidationException(_inner) => {
         249  +
                _inner.name()
         250  +
            }
  298    251   
        }
  299    252   
    }
  300    253   
}
  301         -
impl ::std::error::Error for ErrorSerializationOperationError {
         254  +
impl ::std::error::Error for StreamingOperationWithInitialResponseError {
  302    255   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  303    256   
        match &self {
  304         -
            ErrorSerializationOperationError::ValidationException(_inner) => Some(_inner),
         257  +
            StreamingOperationWithInitialResponseError::ValidationException(_inner) => Some(_inner),
  305    258   
        }
  306    259   
    }
  307    260   
}
  308    261   
impl ::std::convert::From<crate::error::ValidationException>
  309         -
    for crate::error::ErrorSerializationOperationError
         262  +
    for crate::error::StreamingOperationWithInitialResponseError
  310    263   
{
  311    264   
    fn from(
  312    265   
        variant: crate::error::ValidationException,
  313         -
    ) -> crate::error::ErrorSerializationOperationError {
         266  +
    ) -> crate::error::StreamingOperationWithInitialResponseError {
  314    267   
        Self::ValidationException(variant)
  315    268   
    }
  316    269   
}
  317    270   
  318         -
/// Error type for the `SimpleStructOperation` operation.
  319         -
/// Each variant represents an error that can occur for the `SimpleStructOperation` operation.
         271  +
/// Error type for the `StreamingOperationWithOptionalData` operation.
         272  +
/// Each variant represents an error that can occur for the `StreamingOperationWithOptionalData` operation.
  320    273   
#[derive(::std::fmt::Debug)]
  321         -
pub enum SimpleStructOperationError {
         274  +
pub enum StreamingOperationWithOptionalDataError {
  322    275   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  323    276   
    ValidationException(crate::error::ValidationException),
  324    277   
}
  325         -
impl ::std::fmt::Display for SimpleStructOperationError {
         278  +
impl ::std::fmt::Display for StreamingOperationWithOptionalDataError {
  326    279   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  327    280   
        match &self {
  328         -
            SimpleStructOperationError::ValidationException(_inner) => _inner.fmt(f),
         281  +
            StreamingOperationWithOptionalDataError::ValidationException(_inner) => _inner.fmt(f),
  329    282   
        }
  330    283   
    }
  331    284   
}
  332         -
impl SimpleStructOperationError {
  333         -
    /// Returns `true` if the error kind is `SimpleStructOperationError::ValidationException`.
         285  +
impl StreamingOperationWithOptionalDataError {
         286  +
    /// Returns `true` if the error kind is `StreamingOperationWithOptionalDataError::ValidationException`.
  334    287   
    pub fn is_validation_exception(&self) -> bool {
  335         -
        matches!(&self, SimpleStructOperationError::ValidationException(_))
         288  +
        matches!(
         289  +
            &self,
         290  +
            StreamingOperationWithOptionalDataError::ValidationException(_)
         291  +
        )
  336    292   
    }
  337    293   
    /// Returns the error name string by matching the correct variant.
  338    294   
    pub fn name(&self) -> &'static str {
  339    295   
        match &self {
  340         -
            SimpleStructOperationError::ValidationException(_inner) => _inner.name(),
         296  +
            StreamingOperationWithOptionalDataError::ValidationException(_inner) => _inner.name(),
  341    297   
        }
  342    298   
    }
  343    299   
}
  344         -
impl ::std::error::Error for SimpleStructOperationError {
         300  +
impl ::std::error::Error for StreamingOperationWithOptionalDataError {
  345    301   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  346    302   
        match &self {
  347         -
            SimpleStructOperationError::ValidationException(_inner) => Some(_inner),
         303  +
            StreamingOperationWithOptionalDataError::ValidationException(_inner) => Some(_inner),
  348    304   
        }
  349    305   
    }
  350    306   
}
  351    307   
impl ::std::convert::From<crate::error::ValidationException>
  352         -
    for crate::error::SimpleStructOperationError
         308  +
    for crate::error::StreamingOperationWithOptionalDataError
  353    309   
{
  354    310   
    fn from(
  355    311   
        variant: crate::error::ValidationException,
  356         -
    ) -> crate::error::SimpleStructOperationError {
         312  +
    ) -> crate::error::StreamingOperationWithOptionalDataError {
  357    313   
        Self::ValidationException(variant)
  358    314   
    }
  359    315   
}
         316  +
         317  +
/// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         318  +
#[derive(
         319  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         320  +
)]
         321  +
pub struct ValidationException {
         322  +
    /// A summary of the validation failure.
         323  +
    pub message: ::std::string::String,
         324  +
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
         325  +
    pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
         326  +
}
         327  +
impl ValidationException {
         328  +
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
         329  +
    pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
         330  +
        self.field_list.as_deref()
         331  +
    }
         332  +
}
         333  +
impl ValidationException {
         334  +
    /// Returns the error message.
         335  +
    pub fn message(&self) -> &str {
         336  +
        &self.message
         337  +
    }
         338  +
    #[doc(hidden)]
         339  +
    /// Returns the error name.
         340  +
    pub fn name(&self) -> &'static str {
         341  +
        "ValidationException"
         342  +
    }
         343  +
}
         344  +
impl ::std::fmt::Display for ValidationException {
         345  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         346  +
        ::std::write!(f, "ValidationException")?;
         347  +
        {
         348  +
            ::std::write!(f, ": {}", &self.message)?;
         349  +
        }
         350  +
        Ok(())
         351  +
    }
         352  +
}
         353  +
impl ::std::error::Error for ValidationException {}
         354  +
impl ValidationException {
         355  +
    /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
         356  +
    pub fn builder() -> crate::error::validation_exception::Builder {
         357  +
        crate::error::validation_exception::Builder::default()
         358  +
    }
         359  +
}
         360  +
  360    361   
/// See [`ValidationException`](crate::error::ValidationException).
  361    362   
pub mod validation_exception {
  362    363   
  363    364   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
  364    365   
    /// Holds one variant for each of the ways the builder can fail.
  365    366   
    #[non_exhaustive]
  366    367   
    #[allow(clippy::enum_variant_names)]
  367    368   
    pub enum ConstraintViolation {
  368    369   
        /// `message` was not provided but it is required when building `ValidationException`.
  369    370   
        MissingMessage,

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

@@ -1,1 +391,107 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3         -
#[derive(::std::fmt::Debug)]
    4         -
pub struct StreamingOperationWithOptionalDataInput {
    5         -
    #[allow(missing_docs)] // documentation missing in model
    6         -
    pub optional_data: ::std::option::Option<::std::string::String>,
    7         -
    #[allow(missing_docs)] // documentation missing in model
    8         -
    pub events: crate::sigv4_event_stream::SigV4Receiver<
    9         -
        crate::model::Events,
   10         -
        ::aws_smithy_http::event_stream::MessageStreamError,
   11         -
    >,
   12         -
}
   13         -
impl StreamingOperationWithOptionalDataInput {
   14         -
    #[allow(missing_docs)] // documentation missing in model
   15         -
    pub fn optional_data(&self) -> ::std::option::Option<&str> {
   16         -
        self.optional_data.as_deref()
   17         -
    }
   18         -
    #[allow(missing_docs)] // documentation missing in model
   19         -
    pub fn events(
   20         -
        &self,
   21         -
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
   22         -
        crate::model::Events,
   23         -
        ::aws_smithy_http::event_stream::MessageStreamError,
   24         -
    > {
   25         -
        &self.events
   26         -
    }
   27         -
}
   28         -
impl StreamingOperationWithOptionalDataInput {
   29         -
    /// Creates a new builder-style object to manufacture [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
   30         -
    pub fn builder() -> crate::input::streaming_operation_with_optional_data_input::Builder {
   31         -
        crate::input::streaming_operation_with_optional_data_input::Builder::default()
   32         -
    }
   33         -
}
   34         -
impl crate::constrained::Constrained for crate::input::StreamingOperationWithOptionalDataInput {
   35         -
    type Unconstrained = crate::input::streaming_operation_with_optional_data_input::Builder;
   36         -
}
   37         -
   38         -
#[allow(missing_docs)] // documentation missing in model
   39         -
#[derive(::std::fmt::Debug)]
   40         -
pub struct StreamingOperationWithInitialResponseInput {
           3  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           4  +
pub struct SimpleStructOperationInput {
   41      5   
    #[allow(missing_docs)] // documentation missing in model
   42         -
    pub events: crate::sigv4_event_stream::SigV4Receiver<
   43         -
        crate::model::Events,
   44         -
        ::aws_smithy_http::event_stream::MessageStreamError,
   45         -
    >,
   46         -
}
   47         -
impl StreamingOperationWithInitialResponseInput {
           6  +
    pub blob: ::std::option::Option<::aws_smithy_types::Blob>,
   48      7   
    #[allow(missing_docs)] // documentation missing in model
   49         -
    pub fn events(
   50         -
        &self,
   51         -
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
   52         -
        crate::model::Events,
   53         -
        ::aws_smithy_http::event_stream::MessageStreamError,
   54         -
    > {
   55         -
        &self.events
   56         -
    }
   57         -
}
   58         -
impl StreamingOperationWithInitialResponseInput {
   59         -
    /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
   60         -
    pub fn builder() -> crate::input::streaming_operation_with_initial_response_input::Builder {
   61         -
        crate::input::streaming_operation_with_initial_response_input::Builder::default()
   62         -
    }
   63         -
}
   64         -
impl crate::constrained::Constrained for crate::input::StreamingOperationWithInitialResponseInput {
   65         -
    type Unconstrained = crate::input::streaming_operation_with_initial_response_input::Builder;
   66         -
}
   67         -
   68         -
#[allow(missing_docs)] // documentation missing in model
   69         -
#[derive(::std::fmt::Debug)]
   70         -
pub struct StreamingOperationWithInitialDataInput {
           8  +
    pub boolean: ::std::option::Option<bool>,
   71      9   
    #[allow(missing_docs)] // documentation missing in model
   72         -
    pub initial_data: ::std::string::String,
          10  +
    pub string: ::std::option::Option<::std::string::String>,
   73     11   
    #[allow(missing_docs)] // documentation missing in model
   74         -
    pub events: crate::sigv4_event_stream::SigV4Receiver<
   75         -
        crate::model::Events,
   76         -
        ::aws_smithy_http::event_stream::MessageStreamError,
   77         -
    >,
   78         -
}
   79         -
impl StreamingOperationWithInitialDataInput {
          12  +
    pub byte: ::std::option::Option<i8>,
   80     13   
    #[allow(missing_docs)] // documentation missing in model
   81         -
    pub fn initial_data(&self) -> &str {
   82         -
        use std::ops::Deref;
   83         -
        self.initial_data.deref()
   84         -
    }
          14  +
    pub short: ::std::option::Option<i16>,
   85     15   
    #[allow(missing_docs)] // documentation missing in model
   86         -
    pub fn events(
   87         -
        &self,
   88         -
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
   89         -
        crate::model::Events,
   90         -
        ::aws_smithy_http::event_stream::MessageStreamError,
   91         -
    > {
   92         -
        &self.events
   93         -
    }
   94         -
}
   95         -
impl StreamingOperationWithInitialDataInput {
   96         -
    /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
   97         -
    pub fn builder() -> crate::input::streaming_operation_with_initial_data_input::Builder {
   98         -
        crate::input::streaming_operation_with_initial_data_input::Builder::default()
   99         -
    }
  100         -
}
  101         -
impl crate::constrained::Constrained for crate::input::StreamingOperationWithInitialDataInput {
  102         -
    type Unconstrained = crate::input::streaming_operation_with_initial_data_input::Builder;
  103         -
}
  104         -
  105         -
#[allow(missing_docs)] // documentation missing in model
  106         -
#[derive(::std::fmt::Debug)]
  107         -
pub struct StreamingOperationInput {
          16  +
    pub integer: ::std::option::Option<i32>,
  108     17   
    #[allow(missing_docs)] // documentation missing in model
  109         -
    pub events: crate::sigv4_event_stream::SigV4Receiver<
  110         -
        crate::model::Events,
  111         -
        ::aws_smithy_http::event_stream::MessageStreamError,
  112         -
    >,
  113         -
}
  114         -
impl StreamingOperationInput {
          18  +
    pub long: ::std::option::Option<i64>,
  115     19   
    #[allow(missing_docs)] // documentation missing in model
  116         -
    pub fn events(
  117         -
        &self,
  118         -
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
  119         -
        crate::model::Events,
  120         -
        ::aws_smithy_http::event_stream::MessageStreamError,
  121         -
    > {
  122         -
        &self.events
  123         -
    }
  124         -
}
  125         -
impl StreamingOperationInput {
  126         -
    /// Creates a new builder-style object to manufacture [`StreamingOperationInput`](crate::input::StreamingOperationInput).
  127         -
    pub fn builder() -> crate::input::streaming_operation_input::Builder {
  128         -
        crate::input::streaming_operation_input::Builder::default()
  129         -
    }
  130         -
}
  131         -
impl crate::constrained::Constrained for crate::input::StreamingOperationInput {
  132         -
    type Unconstrained = crate::input::streaming_operation_input::Builder;
  133         -
}
  134         -
  135         -
#[allow(missing_docs)] // documentation missing in model
  136         -
#[derive(
  137         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  138         -
)]
  139         -
pub struct RecursiveUnionOperationInput {
          20  +
    pub float: ::std::option::Option<f32>,
  140     21   
    #[allow(missing_docs)] // documentation missing in model
  141         -
    pub nested: ::std::option::Option<crate::model::RecursiveOperationInputOutputNested1>,
  142         -
}
  143         -
impl RecursiveUnionOperationInput {
          22  +
    pub double: ::std::option::Option<f64>,
  144     23   
    #[allow(missing_docs)] // documentation missing in model
  145         -
    pub fn nested(
  146         -
        &self,
  147         -
    ) -> ::std::option::Option<&crate::model::RecursiveOperationInputOutputNested1> {
  148         -
        self.nested.as_ref()
  149         -
    }
  150         -
}
  151         -
impl RecursiveUnionOperationInput {
  152         -
    /// Creates a new builder-style object to manufacture [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
  153         -
    pub fn builder() -> crate::input::recursive_union_operation_input::Builder {
  154         -
        crate::input::recursive_union_operation_input::Builder::default()
  155         -
    }
  156         -
}
  157         -
impl crate::constrained::Constrained for crate::input::RecursiveUnionOperationInput {
  158         -
    type Unconstrained = crate::input::recursive_union_operation_input::Builder;
  159         -
}
  160         -
  161         -
#[allow(missing_docs)] // documentation missing in model
  162         -
#[derive(
  163         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  164         -
)]
  165         -
pub struct SingleMemberStructOperationInput {
          24  +
    pub timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
  166     25   
    #[allow(missing_docs)] // documentation missing in model
  167         -
    pub message: ::std::option::Option<::std::string::String>,
  168         -
}
  169         -
impl SingleMemberStructOperationInput {
          26  +
    pub r#enum: ::std::option::Option<crate::model::Suit>,
  170     27   
    #[allow(missing_docs)] // documentation missing in model
  171         -
    pub fn message(&self) -> ::std::option::Option<&str> {
  172         -
        self.message.as_deref()
  173         -
    }
  174         -
}
  175         -
impl SingleMemberStructOperationInput {
  176         -
    /// Creates a new builder-style object to manufacture [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
  177         -
    pub fn builder() -> crate::input::single_member_struct_operation_input::Builder {
  178         -
        crate::input::single_member_struct_operation_input::Builder::default()
  179         -
    }
  180         -
}
  181         -
impl crate::constrained::Constrained for crate::input::SingleMemberStructOperationInput {
  182         -
    type Unconstrained = crate::input::single_member_struct_operation_input::Builder;
  183         -
}
  184         -
  185         -
#[allow(missing_docs)] // documentation missing in model
  186         -
#[derive(
  187         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  188         -
)]
  189         -
pub struct EmptyStructOperationInput {}
  190         -
impl EmptyStructOperationInput {
  191         -
    /// Creates a new builder-style object to manufacture [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
  192         -
    pub fn builder() -> crate::input::empty_struct_operation_input::Builder {
  193         -
        crate::input::empty_struct_operation_input::Builder::default()
  194         -
    }
  195         -
}
  196         -
impl crate::constrained::Constrained for crate::input::EmptyStructOperationInput {
  197         -
    type Unconstrained = crate::input::empty_struct_operation_input::Builder;
  198         -
}
  199         -
  200         -
#[allow(missing_docs)] // documentation missing in model
  201         -
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
  202         -
pub struct ComplexStructOperationInput {
          28  +
    pub required_blob: ::aws_smithy_types::Blob,
  203     29   
    #[allow(missing_docs)] // documentation missing in model
  204         -
    pub structure: ::std::option::Option<crate::model::SimpleStruct>,
          30  +
    pub required_boolean: bool,
  205     31   
    #[allow(missing_docs)] // documentation missing in model
  206         -
    pub empty_structure: ::std::option::Option<crate::model::EmptyStruct>,
          32  +
    pub required_string: ::std::string::String,
  207     33   
    #[allow(missing_docs)] // documentation missing in model
  208         -
    pub list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          34  +
    pub required_byte: i8,
  209     35   
    #[allow(missing_docs)] // documentation missing in model
  210         -
    pub map: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
          36  +
    pub required_short: i16,
  211     37   
    #[allow(missing_docs)] // documentation missing in model
  212         -
    pub union: ::std::option::Option<crate::model::SimpleUnion>,
          38  +
    pub required_integer: i32,
  213     39   
    #[allow(missing_docs)] // documentation missing in model
  214         -
    pub unit_union: ::std::option::Option<crate::model::UnitUnion>,
          40  +
    pub required_long: i64,
  215     41   
    #[allow(missing_docs)] // documentation missing in model
  216         -
    pub structure_list: ::std::option::Option<::std::vec::Vec<crate::model::SimpleStruct>>,
          42  +
    pub required_float: f32,
  217     43   
    #[allow(missing_docs)] // documentation missing in model
  218         -
    pub complex_list: ::std::vec::Vec<
  219         -
        ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
  220         -
    >,
          44  +
    pub required_double: f64,
  221     45   
    #[allow(missing_docs)] // documentation missing in model
  222         -
    pub complex_map: ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
          46  +
    pub required_timestamp: ::aws_smithy_types::DateTime,
  223     47   
    #[allow(missing_docs)] // documentation missing in model
  224         -
    pub complex_union: ::std::boxed::Box<crate::model::ComplexUnion>,
          48  +
    pub required_enum: crate::model::Suit,
  225     49   
}
  226         -
impl ComplexStructOperationInput {
          50  +
impl SimpleStructOperationInput {
  227     51   
    #[allow(missing_docs)] // documentation missing in model
  228         -
    pub fn structure(&self) -> ::std::option::Option<&crate::model::SimpleStruct> {
  229         -
        self.structure.as_ref()
          52  +
    pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
          53  +
        self.blob.as_ref()
  230     54   
    }
  231     55   
    #[allow(missing_docs)] // documentation missing in model
  232         -
    pub fn empty_structure(&self) -> ::std::option::Option<&crate::model::EmptyStruct> {
  233         -
        self.empty_structure.as_ref()
          56  +
    pub fn boolean(&self) -> ::std::option::Option<bool> {
          57  +
        self.boolean
  234     58   
    }
  235     59   
    #[allow(missing_docs)] // documentation missing in model
  236         -
    pub fn list(&self) -> ::std::option::Option<&[::std::string::String]> {
  237         -
        self.list.as_deref()
          60  +
    pub fn string(&self) -> ::std::option::Option<&str> {
          61  +
        self.string.as_deref()
  238     62   
    }
  239     63   
    #[allow(missing_docs)] // documentation missing in model
  240         -
    pub fn map(
  241         -
        &self,
  242         -
    ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
  243         -
        self.map.as_ref()
          64  +
    pub fn byte(&self) -> ::std::option::Option<i8> {
          65  +
        self.byte
  244     66   
    }
  245     67   
    #[allow(missing_docs)] // documentation missing in model
  246         -
    pub fn union(&self) -> ::std::option::Option<&crate::model::SimpleUnion> {
  247         -
        self.union.as_ref()
          68  +
    pub fn short(&self) -> ::std::option::Option<i16> {
          69  +
        self.short
  248     70   
    }
  249     71   
    #[allow(missing_docs)] // documentation missing in model
  250         -
    pub fn unit_union(&self) -> ::std::option::Option<&crate::model::UnitUnion> {
  251         -
        self.unit_union.as_ref()
          72  +
    pub fn integer(&self) -> ::std::option::Option<i32> {
          73  +
        self.integer
  252     74   
    }
  253     75   
    #[allow(missing_docs)] // documentation missing in model
  254         -
    pub fn structure_list(&self) -> ::std::option::Option<&[crate::model::SimpleStruct]> {
  255         -
        self.structure_list.as_deref()
  256         -
    }
  257         -
    #[allow(missing_docs)] // documentation missing in model
  258         -
    pub fn complex_list(
  259         -
        &self,
  260         -
    ) -> &[::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>] {
  261         -
        use std::ops::Deref;
  262         -
        self.complex_list.deref()
  263         -
    }
  264         -
    #[allow(missing_docs)] // documentation missing in model
  265         -
    pub fn complex_map(
  266         -
        &self,
  267         -
    ) -> &::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion> {
  268         -
        &self.complex_map
  269         -
    }
  270         -
    #[allow(missing_docs)] // documentation missing in model
  271         -
    pub fn complex_union(&self) -> &crate::model::ComplexUnion {
  272         -
        use std::ops::Deref;
  273         -
        self.complex_union.deref()
  274         -
    }
  275         -
}
  276         -
impl ComplexStructOperationInput {
  277         -
    /// Creates a new builder-style object to manufacture [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
  278         -
    pub fn builder() -> crate::input::complex_struct_operation_input::Builder {
  279         -
        crate::input::complex_struct_operation_input::Builder::default()
  280         -
    }
  281         -
}
  282         -
impl crate::constrained::Constrained for crate::input::ComplexStructOperationInput {
  283         -
    type Unconstrained = crate::input::complex_struct_operation_input::Builder;
  284         -
}
  285         -
  286         -
#[allow(missing_docs)] // documentation missing in model
  287         -
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
  288         -
pub struct ErrorSerializationOperationInput {
  289         -
    #[allow(missing_docs)] // documentation missing in model
  290         -
    pub blob: ::std::option::Option<::aws_smithy_types::Blob>,
  291         -
    #[allow(missing_docs)] // documentation missing in model
  292         -
    pub boolean: ::std::option::Option<bool>,
  293         -
    #[allow(missing_docs)] // documentation missing in model
  294         -
    pub string: ::std::option::Option<::std::string::String>,
  295         -
    #[allow(missing_docs)] // documentation missing in model
  296         -
    pub byte: ::std::option::Option<i8>,
  297         -
    #[allow(missing_docs)] // documentation missing in model
  298         -
    pub short: ::std::option::Option<i16>,
  299         -
    #[allow(missing_docs)] // documentation missing in model
  300         -
    pub integer: ::std::option::Option<i32>,
  301         -
    #[allow(missing_docs)] // documentation missing in model
  302         -
    pub long: ::std::option::Option<i64>,
  303         -
    #[allow(missing_docs)] // documentation missing in model
  304         -
    pub float: ::std::option::Option<f32>,
  305         -
    #[allow(missing_docs)] // documentation missing in model
  306         -
    pub double: ::std::option::Option<f64>,
  307         -
    #[allow(missing_docs)] // documentation missing in model
  308         -
    pub timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
  309         -
    #[allow(missing_docs)] // documentation missing in model
  310         -
    pub r#enum: ::std::option::Option<crate::model::Suit>,
  311         -
    #[allow(missing_docs)] // documentation missing in model
  312         -
    pub required_blob: ::aws_smithy_types::Blob,
  313         -
    #[allow(missing_docs)] // documentation missing in model
  314         -
    pub required_boolean: bool,
  315         -
    #[allow(missing_docs)] // documentation missing in model
  316         -
    pub required_string: ::std::string::String,
  317         -
    #[allow(missing_docs)] // documentation missing in model
  318         -
    pub required_byte: i8,
  319         -
    #[allow(missing_docs)] // documentation missing in model
  320         -
    pub required_short: i16,
  321         -
    #[allow(missing_docs)] // documentation missing in model
  322         -
    pub required_integer: i32,
  323         -
    #[allow(missing_docs)] // documentation missing in model
  324         -
    pub required_long: i64,
  325         -
    #[allow(missing_docs)] // documentation missing in model
  326         -
    pub required_float: f32,
  327         -
    #[allow(missing_docs)] // documentation missing in model
  328         -
    pub required_double: f64,
  329         -
    #[allow(missing_docs)] // documentation missing in model
  330         -
    pub required_timestamp: ::aws_smithy_types::DateTime,
  331         -
    #[allow(missing_docs)] // documentation missing in model
  332         -
    pub required_enum: crate::model::Suit,
  333         -
}
  334         -
impl ErrorSerializationOperationInput {
  335         -
    #[allow(missing_docs)] // documentation missing in model
  336         -
    pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
  337         -
        self.blob.as_ref()
  338         -
    }
  339         -
    #[allow(missing_docs)] // documentation missing in model
  340         -
    pub fn boolean(&self) -> ::std::option::Option<bool> {
  341         -
        self.boolean
  342         -
    }
  343         -
    #[allow(missing_docs)] // documentation missing in model
  344         -
    pub fn string(&self) -> ::std::option::Option<&str> {
  345         -
        self.string.as_deref()
  346         -
    }
  347         -
    #[allow(missing_docs)] // documentation missing in model
  348         -
    pub fn byte(&self) -> ::std::option::Option<i8> {
  349         -
        self.byte
  350         -
    }
  351         -
    #[allow(missing_docs)] // documentation missing in model
  352         -
    pub fn short(&self) -> ::std::option::Option<i16> {
  353         -
        self.short
  354         -
    }
  355         -
    #[allow(missing_docs)] // documentation missing in model
  356         -
    pub fn integer(&self) -> ::std::option::Option<i32> {
  357         -
        self.integer
  358         -
    }
  359         -
    #[allow(missing_docs)] // documentation missing in model
  360         -
    pub fn long(&self) -> ::std::option::Option<i64> {
  361         -
        self.long
          76  +
    pub fn long(&self) -> ::std::option::Option<i64> {
          77  +
        self.long
  362     78   
    }
  363     79   
    #[allow(missing_docs)] // documentation missing in model
  364     80   
    pub fn float(&self) -> ::std::option::Option<f32> {
  365     81   
        self.float
  366     82   
    }
  367     83   
    #[allow(missing_docs)] // documentation missing in model
  368     84   
    pub fn double(&self) -> ::std::option::Option<f64> {
  369     85   
        self.double
  370     86   
    }
  371     87   
    #[allow(missing_docs)] // documentation missing in model
@@ -395,111 +513,229 @@
  415    131   
    }
  416    132   
    #[allow(missing_docs)] // documentation missing in model
  417    133   
    pub fn required_timestamp(&self) -> &::aws_smithy_types::DateTime {
  418    134   
        &self.required_timestamp
  419    135   
    }
  420    136   
    #[allow(missing_docs)] // documentation missing in model
  421    137   
    pub fn required_enum(&self) -> &crate::model::Suit {
  422    138   
        &self.required_enum
  423    139   
    }
  424    140   
}
  425         -
impl ErrorSerializationOperationInput {
  426         -
    /// Creates a new builder-style object to manufacture [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
  427         -
    pub fn builder() -> crate::input::error_serialization_operation_input::Builder {
  428         -
        crate::input::error_serialization_operation_input::Builder::default()
         141  +
impl SimpleStructOperationInput {
         142  +
    /// Creates a new builder-style object to manufacture [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
         143  +
    pub fn builder() -> crate::input::simple_struct_operation_input::Builder {
         144  +
        crate::input::simple_struct_operation_input::Builder::default()
  429    145   
    }
  430    146   
}
  431         -
impl crate::constrained::Constrained for crate::input::ErrorSerializationOperationInput {
  432         -
    type Unconstrained = crate::input::error_serialization_operation_input::Builder;
         147  +
impl crate::constrained::Constrained for crate::input::SimpleStructOperationInput {
         148  +
    type Unconstrained = crate::input::simple_struct_operation_input::Builder;
  433    149   
}
  434    150   
  435    151   
#[allow(missing_docs)] // documentation missing in model
  436    152   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
  437         -
pub struct SimpleStructOperationInput {
         153  +
pub struct ErrorSerializationOperationInput {
  438    154   
    #[allow(missing_docs)] // documentation missing in model
  439    155   
    pub blob: ::std::option::Option<::aws_smithy_types::Blob>,
  440    156   
    #[allow(missing_docs)] // documentation missing in model
  441    157   
    pub boolean: ::std::option::Option<bool>,
  442    158   
    #[allow(missing_docs)] // documentation missing in model
  443    159   
    pub string: ::std::option::Option<::std::string::String>,
  444    160   
    #[allow(missing_docs)] // documentation missing in model
  445    161   
    pub byte: ::std::option::Option<i8>,
  446    162   
    #[allow(missing_docs)] // documentation missing in model
  447    163   
    pub short: ::std::option::Option<i16>,
  448    164   
    #[allow(missing_docs)] // documentation missing in model
  449    165   
    pub integer: ::std::option::Option<i32>,
  450    166   
    #[allow(missing_docs)] // documentation missing in model
  451    167   
    pub long: ::std::option::Option<i64>,
  452    168   
    #[allow(missing_docs)] // documentation missing in model
  453    169   
    pub float: ::std::option::Option<f32>,
  454    170   
    #[allow(missing_docs)] // documentation missing in model
  455    171   
    pub double: ::std::option::Option<f64>,
  456    172   
    #[allow(missing_docs)] // documentation missing in model
  457    173   
    pub timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
  458    174   
    #[allow(missing_docs)] // documentation missing in model
  459    175   
    pub r#enum: ::std::option::Option<crate::model::Suit>,
  460    176   
    #[allow(missing_docs)] // documentation missing in model
  461    177   
    pub required_blob: ::aws_smithy_types::Blob,
  462    178   
    #[allow(missing_docs)] // documentation missing in model
  463    179   
    pub required_boolean: bool,
  464    180   
    #[allow(missing_docs)] // documentation missing in model
  465    181   
    pub required_string: ::std::string::String,
  466    182   
    #[allow(missing_docs)] // documentation missing in model
  467    183   
    pub required_byte: i8,
  468    184   
    #[allow(missing_docs)] // documentation missing in model
  469    185   
    pub required_short: i16,
  470    186   
    #[allow(missing_docs)] // documentation missing in model
  471    187   
    pub required_integer: i32,
  472    188   
    #[allow(missing_docs)] // documentation missing in model
  473    189   
    pub required_long: i64,
  474    190   
    #[allow(missing_docs)] // documentation missing in model
  475    191   
    pub required_float: f32,
  476    192   
    #[allow(missing_docs)] // documentation missing in model
  477    193   
    pub required_double: f64,
  478    194   
    #[allow(missing_docs)] // documentation missing in model
  479    195   
    pub required_timestamp: ::aws_smithy_types::DateTime,
  480    196   
    #[allow(missing_docs)] // documentation missing in model
  481    197   
    pub required_enum: crate::model::Suit,
  482    198   
}
  483         -
impl SimpleStructOperationInput {
         199  +
impl ErrorSerializationOperationInput {
  484    200   
    #[allow(missing_docs)] // documentation missing in model
  485    201   
    pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
  486    202   
        self.blob.as_ref()
  487    203   
    }
  488    204   
    #[allow(missing_docs)] // documentation missing in model
  489    205   
    pub fn boolean(&self) -> ::std::option::Option<bool> {
  490    206   
        self.boolean
  491    207   
    }
  492    208   
    #[allow(missing_docs)] // documentation missing in model
  493    209   
    pub fn string(&self) -> ::std::option::Option<&str> {
@@ -544,260 +2625,2625 @@
  564    280   
    }
  565    281   
    #[allow(missing_docs)] // documentation missing in model
  566    282   
    pub fn required_timestamp(&self) -> &::aws_smithy_types::DateTime {
  567    283   
        &self.required_timestamp
  568    284   
    }
  569    285   
    #[allow(missing_docs)] // documentation missing in model
  570    286   
    pub fn required_enum(&self) -> &crate::model::Suit {
  571    287   
        &self.required_enum
  572    288   
    }
  573    289   
}
  574         -
impl SimpleStructOperationInput {
  575         -
    /// Creates a new builder-style object to manufacture [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
  576         -
    pub fn builder() -> crate::input::simple_struct_operation_input::Builder {
  577         -
        crate::input::simple_struct_operation_input::Builder::default()
         290  +
impl ErrorSerializationOperationInput {
         291  +
    /// Creates a new builder-style object to manufacture [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
         292  +
    pub fn builder() -> crate::input::error_serialization_operation_input::Builder {
         293  +
        crate::input::error_serialization_operation_input::Builder::default()
  578    294   
    }
  579    295   
}
  580         -
impl crate::constrained::Constrained for crate::input::SimpleStructOperationInput {
  581         -
    type Unconstrained = crate::input::simple_struct_operation_input::Builder;
         296  +
impl crate::constrained::Constrained for crate::input::ErrorSerializationOperationInput {
         297  +
    type Unconstrained = crate::input::error_serialization_operation_input::Builder;
  582    298   
}
  583         -
/// See [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
  584         -
pub mod streaming_operation_with_optional_data_input {
  585    299   
  586         -
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
  587         -
    /// Holds one variant for each of the ways the builder can fail.
  588         -
    #[non_exhaustive]
  589         -
    #[allow(clippy::enum_variant_names)]
  590         -
    pub enum ConstraintViolation {
  591         -
        /// `events` was not provided but it is required when building `StreamingOperationWithOptionalDataInput`.
  592         -
        MissingEvents,
         300  +
#[allow(missing_docs)] // documentation missing in model
         301  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
         302  +
pub struct ComplexStructOperationInput {
         303  +
    #[allow(missing_docs)] // documentation missing in model
         304  +
    pub structure: ::std::option::Option<crate::model::SimpleStruct>,
         305  +
    #[allow(missing_docs)] // documentation missing in model
         306  +
    pub empty_structure: ::std::option::Option<crate::model::EmptyStruct>,
         307  +
    #[allow(missing_docs)] // documentation missing in model
         308  +
    pub list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         309  +
    #[allow(missing_docs)] // documentation missing in model
         310  +
    pub map: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
         311  +
    #[allow(missing_docs)] // documentation missing in model
         312  +
    pub union: ::std::option::Option<crate::model::SimpleUnion>,
         313  +
    #[allow(missing_docs)] // documentation missing in model
         314  +
    pub unit_union: ::std::option::Option<crate::model::UnitUnion>,
         315  +
    #[allow(missing_docs)] // documentation missing in model
         316  +
    pub structure_list: ::std::option::Option<::std::vec::Vec<crate::model::SimpleStruct>>,
         317  +
    #[allow(missing_docs)] // documentation missing in model
         318  +
    pub complex_list: ::std::vec::Vec<
         319  +
        ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
         320  +
    >,
         321  +
    #[allow(missing_docs)] // documentation missing in model
         322  +
    pub complex_map: ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
         323  +
    #[allow(missing_docs)] // documentation missing in model
         324  +
    pub complex_union: ::std::boxed::Box<crate::model::ComplexUnion>,
         325  +
}
         326  +
impl ComplexStructOperationInput {
         327  +
    #[allow(missing_docs)] // documentation missing in model
         328  +
    pub fn structure(&self) -> ::std::option::Option<&crate::model::SimpleStruct> {
         329  +
        self.structure.as_ref()
  593    330   
    }
  594         -
    impl ::std::fmt::Display for ConstraintViolation {
  595         -
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  596         -
            match self {
  597         -
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationWithOptionalDataInput`"),
  598         -
            }
  599         -
        }
         331  +
    #[allow(missing_docs)] // documentation missing in model
         332  +
    pub fn empty_structure(&self) -> ::std::option::Option<&crate::model::EmptyStruct> {
         333  +
        self.empty_structure.as_ref()
  600    334   
    }
  601         -
    impl ::std::error::Error for ConstraintViolation {}
  602         -
    impl ConstraintViolation {
  603         -
        pub(crate) fn as_validation_exception_field(
  604         -
            self,
  605         -
            path: ::std::string::String,
  606         -
        ) -> crate::model::ValidationExceptionField {
  607         -
            match self {
  608         -
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
  609         -
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
  610         -
                                                path: path + "/events",
  611         -
                                            },
  612         -
        }
  613         -
        }
         335  +
    #[allow(missing_docs)] // documentation missing in model
         336  +
    pub fn list(&self) -> ::std::option::Option<&[::std::string::String]> {
         337  +
        self.list.as_deref()
  614    338   
    }
  615         -
    impl ::std::convert::From<ConstraintViolation>
  616         -
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
  617         -
    {
  618         -
        fn from(constraint_violation: ConstraintViolation) -> Self {
  619         -
            let first_validation_exception_field =
  620         -
                constraint_violation.as_validation_exception_field("".to_owned());
  621         -
            let validation_exception = crate::error::ValidationException {
  622         -
                message: format!(
  623         -
                    "1 validation error detected. {}",
  624         -
                    &first_validation_exception_field.message
  625         -
                ),
  626         -
                field_list: Some(vec![first_validation_exception_field]),
  627         -
            };
  628         -
            Self::ConstraintViolation(
  629         -
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
  630         -
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
  631         -
                            )
  632         -
        }
         339  +
    #[allow(missing_docs)] // documentation missing in model
         340  +
    pub fn map(
         341  +
        &self,
         342  +
    ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
         343  +
        self.map.as_ref()
  633    344   
    }
  634         -
    impl ::std::convert::From<Builder>
  635         -
        for crate::constrained::MaybeConstrained<
  636         -
            crate::input::StreamingOperationWithOptionalDataInput,
  637         -
        >
  638         -
    {
  639         -
        fn from(builder: Builder) -> Self {
  640         -
            Self::Unconstrained(builder)
  641         -
        }
         345  +
    #[allow(missing_docs)] // documentation missing in model
         346  +
    pub fn union(&self) -> ::std::option::Option<&crate::model::SimpleUnion> {
         347  +
        self.union.as_ref()
  642    348   
    }
  643         -
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationWithOptionalDataInput {
  644         -
        type Error = ConstraintViolation;
  645         -
  646         -
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
  647         -
            builder.build()
  648         -
        }
         349  +
    #[allow(missing_docs)] // documentation missing in model
         350  +
    pub fn unit_union(&self) -> ::std::option::Option<&crate::model::UnitUnion> {
         351  +
        self.unit_union.as_ref()
  649    352   
    }
  650         -
    /// A builder for [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
  651         -
    #[derive(::std::default::Default, ::std::fmt::Debug)]
  652         -
    pub struct Builder {
  653         -
        pub(crate) optional_data: ::std::option::Option<::std::string::String>,
  654         -
        pub(crate) events: ::std::option::Option<
  655         -
            crate::sigv4_event_stream::SigV4Receiver<
  656         -
                crate::model::Events,
  657         -
                ::aws_smithy_http::event_stream::MessageStreamError,
  658         -
            >,
  659         -
        >,
         353  +
    #[allow(missing_docs)] // documentation missing in model
         354  +
    pub fn structure_list(&self) -> ::std::option::Option<&[crate::model::SimpleStruct]> {
         355  +
        self.structure_list.as_deref()
  660    356   
    }
  661         -
    impl Builder {
  662         -
        #[allow(missing_docs)] // documentation missing in model
  663         -
        pub fn optional_data(
  664         -
            mut self,
  665         -
            input: ::std::option::Option<::std::string::String>,
  666         -
        ) -> Self {
  667         -
            self.optional_data = input;
  668         -
            self
  669         -
        }
  670         -
        #[allow(missing_docs)] // documentation missing in model
  671         -
        pub(crate) fn set_optional_data(
  672         -
            mut self,
  673         -
            input: Option<impl ::std::convert::Into<::std::string::String>>,
  674         -
        ) -> Self {
  675         -
            self.optional_data = input.map(|v| v.into());
  676         -
            self
  677         -
        }
  678         -
        #[allow(missing_docs)] // documentation missing in model
  679         -
        pub fn events(
  680         -
            mut self,
  681         -
            input: crate::sigv4_event_stream::SigV4Receiver<
  682         -
                crate::model::Events,
  683         -
                ::aws_smithy_http::event_stream::MessageStreamError,
  684         -
            >,
  685         -
        ) -> Self {
  686         -
            self.events = Some(input);
  687         -
            self
  688         -
        }
  689         -
        #[allow(missing_docs)] // documentation missing in model
  690         -
        pub(crate) fn set_events(
  691         -
            mut self,
  692         -
            input: impl ::std::convert::Into<
  693         -
                crate::sigv4_event_stream::SigV4Receiver<
  694         -
                    crate::model::Events,
  695         -
                    ::aws_smithy_http::event_stream::MessageStreamError,
  696         -
                >,
  697         -
            >,
  698         -
        ) -> Self {
  699         -
            self.events = Some(input.into());
  700         -
            self
  701         -
        }
  702         -
        /// Consumes the builder and constructs a [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
  703         -
        ///
  704         -
        /// The builder fails to construct a [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput) if a [`ConstraintViolation`] occurs.
  705         -
        ///
  706         -
        pub fn build(
  707         -
            self,
  708         -
        ) -> Result<crate::input::StreamingOperationWithOptionalDataInput, ConstraintViolation>
  709         -
        {
  710         -
            self.build_enforcing_all_constraints()
  711         -
        }
  712         -
        fn build_enforcing_all_constraints(
  713         -
            self,
  714         -
        ) -> Result<crate::input::StreamingOperationWithOptionalDataInput, ConstraintViolation>
  715         -
        {
  716         -
            Ok(crate::input::StreamingOperationWithOptionalDataInput {
  717         -
                optional_data: self.optional_data,
  718         -
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
  719         -
            })
  720         -
        }
         357  +
    #[allow(missing_docs)] // documentation missing in model
         358  +
    pub fn complex_list(
         359  +
        &self,
         360  +
    ) -> &[::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>] {
         361  +
        use std::ops::Deref;
         362  +
        self.complex_list.deref()
         363  +
    }
         364  +
    #[allow(missing_docs)] // documentation missing in model
         365  +
    pub fn complex_map(
         366  +
        &self,
         367  +
    ) -> &::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion> {
         368  +
        &self.complex_map
         369  +
    }
         370  +
    #[allow(missing_docs)] // documentation missing in model
         371  +
    pub fn complex_union(&self) -> &crate::model::ComplexUnion {
         372  +
        use std::ops::Deref;
         373  +
        self.complex_union.deref()
  721    374   
    }
  722    375   
}
  723         -
/// See [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
  724         -
pub mod streaming_operation_with_initial_response_input {
         376  +
impl ComplexStructOperationInput {
         377  +
    /// Creates a new builder-style object to manufacture [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
         378  +
    pub fn builder() -> crate::input::complex_struct_operation_input::Builder {
         379  +
        crate::input::complex_struct_operation_input::Builder::default()
         380  +
    }
         381  +
}
         382  +
impl crate::constrained::Constrained for crate::input::ComplexStructOperationInput {
         383  +
    type Unconstrained = crate::input::complex_struct_operation_input::Builder;
         384  +
}
  725    385   
  726         -
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
  727         -
    /// Holds one variant for each of the ways the builder can fail.
  728         -
    #[non_exhaustive]
  729         -
    #[allow(clippy::enum_variant_names)]
  730         -
    pub enum ConstraintViolation {
  731         -
        /// `events` was not provided but it is required when building `StreamingOperationWithInitialResponseInput`.
  732         -
        MissingEvents,
         386  +
#[allow(missing_docs)] // documentation missing in model
         387  +
#[derive(
         388  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         389  +
)]
         390  +
pub struct EmptyStructOperationInput {}
         391  +
impl EmptyStructOperationInput {
         392  +
    /// Creates a new builder-style object to manufacture [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
         393  +
    pub fn builder() -> crate::input::empty_struct_operation_input::Builder {
         394  +
        crate::input::empty_struct_operation_input::Builder::default()
  733    395   
    }
  734         -
    impl ::std::fmt::Display for ConstraintViolation {
  735         -
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  736         -
            match self {
  737         -
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationWithInitialResponseInput`"),
  738         -
            }
  739         -
        }
         396  +
}
         397  +
impl crate::constrained::Constrained for crate::input::EmptyStructOperationInput {
         398  +
    type Unconstrained = crate::input::empty_struct_operation_input::Builder;
         399  +
}
         400  +
         401  +
#[allow(missing_docs)] // documentation missing in model
         402  +
#[derive(
         403  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         404  +
)]
         405  +
pub struct SingleMemberStructOperationInput {
         406  +
    #[allow(missing_docs)] // documentation missing in model
         407  +
    pub message: ::std::option::Option<::std::string::String>,
         408  +
}
         409  +
impl SingleMemberStructOperationInput {
         410  +
    #[allow(missing_docs)] // documentation missing in model
         411  +
    pub fn message(&self) -> ::std::option::Option<&str> {
         412  +
        self.message.as_deref()
  740    413   
    }
  741         -
    impl ::std::error::Error for ConstraintViolation {}
  742         -
    impl ConstraintViolation {
  743         -
        pub(crate) fn as_validation_exception_field(
  744         -
            self,
  745         -
            path: ::std::string::String,
  746         -
        ) -> crate::model::ValidationExceptionField {
  747         -
            match self {
  748         -
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
  749         -
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
  750         -
                                                path: path + "/events",
  751         -
                                            },
  752         -
        }
  753         -
        }
         414  +
}
         415  +
impl SingleMemberStructOperationInput {
         416  +
    /// Creates a new builder-style object to manufacture [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
         417  +
    pub fn builder() -> crate::input::single_member_struct_operation_input::Builder {
         418  +
        crate::input::single_member_struct_operation_input::Builder::default()
  754    419   
    }
  755         -
    impl ::std::convert::From<ConstraintViolation>
  756         -
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
  757         -
    {
  758         -
        fn from(constraint_violation: ConstraintViolation) -> Self {
  759         -
            let first_validation_exception_field =
  760         -
                constraint_violation.as_validation_exception_field("".to_owned());
  761         -
            let validation_exception = crate::error::ValidationException {
  762         -
                message: format!(
  763         -
                    "1 validation error detected. {}",
  764         -
                    &first_validation_exception_field.message
  765         -
                ),
  766         -
                field_list: Some(vec![first_validation_exception_field]),
  767         -
            };
  768         -
            Self::ConstraintViolation(
  769         -
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
  770         -
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
  771         -
                            )
  772         -
        }
         420  +
}
         421  +
impl crate::constrained::Constrained for crate::input::SingleMemberStructOperationInput {
         422  +
    type Unconstrained = crate::input::single_member_struct_operation_input::Builder;
         423  +
}
         424  +
         425  +
#[allow(missing_docs)] // documentation missing in model
         426  +
#[derive(
         427  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         428  +
)]
         429  +
pub struct RecursiveUnionOperationInput {
         430  +
    #[allow(missing_docs)] // documentation missing in model
         431  +
    pub nested: ::std::option::Option<crate::model::RecursiveOperationInputOutputNested1>,
         432  +
}
         433  +
impl RecursiveUnionOperationInput {
         434  +
    #[allow(missing_docs)] // documentation missing in model
         435  +
    pub fn nested(
         436  +
        &self,
         437  +
    ) -> ::std::option::Option<&crate::model::RecursiveOperationInputOutputNested1> {
         438  +
        self.nested.as_ref()
  773    439   
    }
  774         -
    impl ::std::convert::From<Builder>
  775         -
        for crate::constrained::MaybeConstrained<
  776         -
            crate::input::StreamingOperationWithInitialResponseInput,
  777         -
        >
  778         -
    {
  779         -
        fn from(builder: Builder) -> Self {
  780         -
            Self::Unconstrained(builder)
  781         -
        }
         440  +
}
         441  +
impl RecursiveUnionOperationInput {
         442  +
    /// Creates a new builder-style object to manufacture [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
         443  +
    pub fn builder() -> crate::input::recursive_union_operation_input::Builder {
         444  +
        crate::input::recursive_union_operation_input::Builder::default()
  782    445   
    }
  783         -
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationWithInitialResponseInput {
  784         -
        type Error = ConstraintViolation;
         446  +
}
         447  +
impl crate::constrained::Constrained for crate::input::RecursiveUnionOperationInput {
         448  +
    type Unconstrained = crate::input::recursive_union_operation_input::Builder;
         449  +
}
  785    450   
  786         -
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
  787         -
            builder.build()
  788         -
        }
  789         -
    }
  790         -
    /// A builder for [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
  791         -
    #[derive(::std::default::Default, ::std::fmt::Debug)]
  792         -
    pub struct Builder {
  793         -
        pub(crate) events: ::std::option::Option<
  794         -
            crate::sigv4_event_stream::SigV4Receiver<
  795         -
                crate::model::Events,
  796         -
                ::aws_smithy_http::event_stream::MessageStreamError,
  797         -
            >,
  798         -
        >,
         451  +
#[allow(missing_docs)] // documentation missing in model
         452  +
#[derive(::std::fmt::Debug)]
         453  +
pub struct StreamingOperationInput {
         454  +
    #[allow(missing_docs)] // documentation missing in model
         455  +
    pub events: crate::sigv4_event_stream::SigV4Receiver<
         456  +
        crate::model::Events,
         457  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         458  +
    >,
         459  +
}
         460  +
impl StreamingOperationInput {
         461  +
    #[allow(missing_docs)] // documentation missing in model
         462  +
    pub fn events(
         463  +
        &self,
         464  +
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
         465  +
        crate::model::Events,
         466  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         467  +
    > {
         468  +
        &self.events
  799    469   
    }
  800         -
    impl Builder {
  801         -
        #[allow(missing_docs)] // documentation missing in model
  802         -
        pub fn events(
  803         -
            mut self,
  804         -
            input: crate::sigv4_event_stream::SigV4Receiver<
  805         -
                crate::model::Events,
  806         -
                ::aws_smithy_http::event_stream::MessageStreamError,
  807         -
            >,
  808         -
        ) -> Self {
  809         -
            self.events = Some(input);
  810         -
            self
  811         -
        }
  812         -
        #[allow(missing_docs)] // documentation missing in model
  813         -
        pub(crate) fn set_events(
  814         -
            mut self,
  815         -
            input: impl ::std::convert::Into<
  816         -
                crate::sigv4_event_stream::SigV4Receiver<
  817         -
                    crate::model::Events,
  818         -
                    ::aws_smithy_http::event_stream::MessageStreamError,
  819         -
                >,
  820         -
            >,
  821         -
        ) -> Self {
  822         -
            self.events = Some(input.into());
  823         -
            self
  824         -
        }
  825         -
        /// Consumes the builder and constructs a [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
  826         -
        ///
  827         -
        /// The builder fails to construct a [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput) if a [`ConstraintViolation`] occurs.
  828         -
        ///
  829         -
        pub fn build(
  830         -
            self,
  831         -
        ) -> Result<crate::input::StreamingOperationWithInitialResponseInput, ConstraintViolation>
  832         -
        {
  833         -
            self.build_enforcing_all_constraints()
  834         -
        }
  835         -
        fn build_enforcing_all_constraints(
  836         -
            self,
  837         -
        ) -> Result<crate::input::StreamingOperationWithInitialResponseInput, ConstraintViolation>
  838         -
        {
  839         -
            Ok(crate::input::StreamingOperationWithInitialResponseInput {
  840         -
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
  841         -
            })
  842         -
        }
         470  +
}
         471  +
impl StreamingOperationInput {
         472  +
    /// Creates a new builder-style object to manufacture [`StreamingOperationInput`](crate::input::StreamingOperationInput).
         473  +
    pub fn builder() -> crate::input::streaming_operation_input::Builder {
         474  +
        crate::input::streaming_operation_input::Builder::default()
  843    475   
    }
  844    476   
}
  845         -
/// See [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
  846         -
pub mod streaming_operation_with_initial_data_input {
         477  +
impl crate::constrained::Constrained for crate::input::StreamingOperationInput {
         478  +
    type Unconstrained = crate::input::streaming_operation_input::Builder;
         479  +
}
  847    480   
  848         -
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
  849         -
    /// Holds one variant for each of the ways the builder can fail.
  850         -
    #[non_exhaustive]
  851         -
    #[allow(clippy::enum_variant_names)]
  852         -
    pub enum ConstraintViolation {
  853         -
        /// `initial_data` was not provided but it is required when building `StreamingOperationWithInitialDataInput`.
  854         -
        MissingInitialData,
  855         -
        /// `events` was not provided but it is required when building `StreamingOperationWithInitialDataInput`.
  856         -
        MissingEvents,
         481  +
#[allow(missing_docs)] // documentation missing in model
         482  +
#[derive(::std::fmt::Debug)]
         483  +
pub struct StreamingOperationWithInitialDataInput {
         484  +
    #[allow(missing_docs)] // documentation missing in model
         485  +
    pub initial_data: ::std::string::String,
         486  +
    #[allow(missing_docs)] // documentation missing in model
         487  +
    pub events: crate::sigv4_event_stream::SigV4Receiver<
         488  +
        crate::model::Events,
         489  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         490  +
    >,
         491  +
}
         492  +
impl StreamingOperationWithInitialDataInput {
         493  +
    #[allow(missing_docs)] // documentation missing in model
         494  +
    pub fn initial_data(&self) -> &str {
         495  +
        use std::ops::Deref;
         496  +
        self.initial_data.deref()
  857    497   
    }
  858         -
    impl ::std::fmt::Display for ConstraintViolation {
  859         -
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  860         -
            match self {
  861         -
                ConstraintViolation::MissingInitialData => write!(f, "`initial_data` was not provided but it is required when building `StreamingOperationWithInitialDataInput`"),
  862         -
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationWithInitialDataInput`"),
  863         -
            }
  864         -
        }
         498  +
    #[allow(missing_docs)] // documentation missing in model
         499  +
    pub fn events(
         500  +
        &self,
         501  +
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
         502  +
        crate::model::Events,
         503  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         504  +
    > {
         505  +
        &self.events
  865    506   
    }
  866         -
    impl ::std::error::Error for ConstraintViolation {}
  867         -
    impl ConstraintViolation {
  868         -
        pub(crate) fn as_validation_exception_field(
  869         -
            self,
  870         -
            path: ::std::string::String,
  871         -
        ) -> crate::model::ValidationExceptionField {
  872         -
            match self {
  873         -
            ConstraintViolation::MissingInitialData => crate::model::ValidationExceptionField {
  874         -
                                                message: format!("Value at '{}/initialData' failed to satisfy constraint: Member must not be null", path),
  875         -
                                                path: path + "/initialData",
  876         -
                                            },
  877         -
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
  878         -
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
  879         -
                                                path: path + "/events",
  880         -
                                            },
  881         -
        }
  882         -
        }
         507  +
}
         508  +
impl StreamingOperationWithInitialDataInput {
         509  +
    /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
         510  +
    pub fn builder() -> crate::input::streaming_operation_with_initial_data_input::Builder {
         511  +
        crate::input::streaming_operation_with_initial_data_input::Builder::default()
  883    512   
    }
  884         -
    impl ::std::convert::From<ConstraintViolation>
  885         -
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
  886         -
    {
  887         -
        fn from(constraint_violation: ConstraintViolation) -> Self {
  888         -
            let first_validation_exception_field =
  889         -
                constraint_violation.as_validation_exception_field("".to_owned());
  890         -
            let validation_exception = crate::error::ValidationException {
  891         -
                message: format!(
  892         -
                    "1 validation error detected. {}",
  893         -
                    &first_validation_exception_field.message
  894         -
                ),
  895         -
                field_list: Some(vec![first_validation_exception_field]),
  896         -
            };
  897         -
            Self::ConstraintViolation(
  898         -
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
  899         -
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
  900         -
                            )
  901         -
        }
         513  +
}
         514  +
impl crate::constrained::Constrained for crate::input::StreamingOperationWithInitialDataInput {
         515  +
    type Unconstrained = crate::input::streaming_operation_with_initial_data_input::Builder;
         516  +
}
         517  +
         518  +
#[allow(missing_docs)] // documentation missing in model
         519  +
#[derive(::std::fmt::Debug)]
         520  +
pub struct StreamingOperationWithInitialResponseInput {
         521  +
    #[allow(missing_docs)] // documentation missing in model
         522  +
    pub events: crate::sigv4_event_stream::SigV4Receiver<
         523  +
        crate::model::Events,
         524  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         525  +
    >,
         526  +
}
         527  +
impl StreamingOperationWithInitialResponseInput {
         528  +
    #[allow(missing_docs)] // documentation missing in model
         529  +
    pub fn events(
         530  +
        &self,
         531  +
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
         532  +
        crate::model::Events,
         533  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         534  +
    > {
         535  +
        &self.events
  902    536   
    }
  903         -
    impl ::std::convert::From<Builder>
  904         -
        for crate::constrained::MaybeConstrained<
  905         -
            crate::input::StreamingOperationWithInitialDataInput,
  906         -
        >
  907         -
    {
  908         -
        fn from(builder: Builder) -> Self {
  909         -
            Self::Unconstrained(builder)
  910         -
        }
         537  +
}
         538  +
impl StreamingOperationWithInitialResponseInput {
         539  +
    /// Creates a new builder-style object to manufacture [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
         540  +
    pub fn builder() -> crate::input::streaming_operation_with_initial_response_input::Builder {
         541  +
        crate::input::streaming_operation_with_initial_response_input::Builder::default()
  911    542   
    }
  912         -
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationWithInitialDataInput {
  913         -
        type Error = ConstraintViolation;
         543  +
}
         544  +
impl crate::constrained::Constrained for crate::input::StreamingOperationWithInitialResponseInput {
         545  +
    type Unconstrained = crate::input::streaming_operation_with_initial_response_input::Builder;
         546  +
}
  914    547   
  915         -
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
  916         -
            builder.build()
  917         -
        }
         548  +
#[allow(missing_docs)] // documentation missing in model
         549  +
#[derive(::std::fmt::Debug)]
         550  +
pub struct StreamingOperationWithOptionalDataInput {
         551  +
    #[allow(missing_docs)] // documentation missing in model
         552  +
    pub optional_data: ::std::option::Option<::std::string::String>,
         553  +
    #[allow(missing_docs)] // documentation missing in model
         554  +
    pub events: crate::sigv4_event_stream::SigV4Receiver<
         555  +
        crate::model::Events,
         556  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         557  +
    >,
         558  +
}
         559  +
impl StreamingOperationWithOptionalDataInput {
         560  +
    #[allow(missing_docs)] // documentation missing in model
         561  +
    pub fn optional_data(&self) -> ::std::option::Option<&str> {
         562  +
        self.optional_data.as_deref()
  918    563   
    }
  919         -
    /// A builder for [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
  920         -
    #[derive(::std::default::Default, ::std::fmt::Debug)]
  921         -
    pub struct Builder {
  922         -
        pub(crate) initial_data: ::std::option::Option<::std::string::String>,
  923         -
        pub(crate) events: ::std::option::Option<
  924         -
            crate::sigv4_event_stream::SigV4Receiver<
  925         -
                crate::model::Events,
  926         -
                ::aws_smithy_http::event_stream::MessageStreamError,
  927         -
            >,
  928         -
        >,
         564  +
    #[allow(missing_docs)] // documentation missing in model
         565  +
    pub fn events(
         566  +
        &self,
         567  +
    ) -> &crate::sigv4_event_stream::SigV4Receiver<
         568  +
        crate::model::Events,
         569  +
        ::aws_smithy_http::event_stream::MessageStreamError,
         570  +
    > {
         571  +
        &self.events
  929    572   
    }
  930         -
    impl Builder {
  931         -
        #[allow(missing_docs)] // documentation missing in model
  932         -
        pub fn initial_data(mut self, input: ::std::string::String) -> Self {
  933         -
            self.initial_data = Some(input);
  934         -
            self
  935         -
        }
  936         -
        #[allow(missing_docs)] // documentation missing in model
  937         -
        pub(crate) fn set_initial_data(
  938         -
            mut self,
  939         -
            input: impl ::std::convert::Into<::std::string::String>,
  940         -
        ) -> Self {
  941         -
            self.initial_data = Some(input.into());
  942         -
            self
  943         -
        }
  944         -
        #[allow(missing_docs)] // documentation missing in model
  945         -
        pub fn events(
  946         -
            mut self,
  947         -
            input: crate::sigv4_event_stream::SigV4Receiver<
  948         -
                crate::model::Events,
  949         -
                ::aws_smithy_http::event_stream::MessageStreamError,
  950         -
            >,
  951         -
        ) -> Self {
  952         -
            self.events = Some(input);
  953         -
            self
  954         -
        }
  955         -
        #[allow(missing_docs)] // documentation missing in model
  956         -
        pub(crate) fn set_events(
  957         -
            mut self,
  958         -
            input: impl ::std::convert::Into<
  959         -
                crate::sigv4_event_stream::SigV4Receiver<
  960         -
                    crate::model::Events,
  961         -
                    ::aws_smithy_http::event_stream::MessageStreamError,
  962         -
                >,
  963         -
            >,
  964         -
        ) -> Self {
  965         -
            self.events = Some(input.into());
  966         -
            self
  967         -
        }
  968         -
        /// Consumes the builder and constructs a [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
  969         -
        ///
  970         -
        /// The builder fails to construct a [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput) if a [`ConstraintViolation`] occurs.
  971         -
        ///
  972         -
        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
  973         -
        pub fn build(
  974         -
            self,
  975         -
        ) -> Result<crate::input::StreamingOperationWithInitialDataInput, ConstraintViolation>
  976         -
        {
  977         -
            self.build_enforcing_all_constraints()
  978         -
        }
  979         -
        fn build_enforcing_all_constraints(
  980         -
            self,
  981         -
        ) -> Result<crate::input::StreamingOperationWithInitialDataInput, ConstraintViolation>
  982         -
        {
  983         -
            Ok(crate::input::StreamingOperationWithInitialDataInput {
  984         -
                initial_data: self
  985         -
                    .initial_data
  986         -
                    .ok_or(ConstraintViolation::MissingInitialData)?,
  987         -
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
  988         -
            })
  989         -
        }
         573  +
}
         574  +
impl StreamingOperationWithOptionalDataInput {
         575  +
    /// Creates a new builder-style object to manufacture [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
         576  +
    pub fn builder() -> crate::input::streaming_operation_with_optional_data_input::Builder {
         577  +
        crate::input::streaming_operation_with_optional_data_input::Builder::default()
  990    578   
    }
  991    579   
}
  992         -
/// See [`StreamingOperationInput`](crate::input::StreamingOperationInput).
  993         -
pub mod streaming_operation_input {
         580  +
impl crate::constrained::Constrained for crate::input::StreamingOperationWithOptionalDataInput {
         581  +
    type Unconstrained = crate::input::streaming_operation_with_optional_data_input::Builder;
         582  +
}
         583  +
/// See [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
         584  +
pub mod simple_struct_operation_input {
  994    585   
  995    586   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
  996    587   
    /// Holds one variant for each of the ways the builder can fail.
  997    588   
    #[non_exhaustive]
  998    589   
    #[allow(clippy::enum_variant_names)]
  999    590   
    pub enum ConstraintViolation {
 1000         -
        /// `events` was not provided but it is required when building `StreamingOperationInput`.
 1001         -
        MissingEvents,
         591  +
        /// Constraint violation occurred building member `r#enum` when building `SimpleStructOperationInput`.
         592  +
        #[doc(hidden)]
         593  +
        Enum(crate::model::suit::ConstraintViolation),
         594  +
        /// `required_blob` was not provided but it is required when building `SimpleStructOperationInput`.
         595  +
        MissingRequiredBlob,
         596  +
        /// `required_boolean` was not provided but it is required when building `SimpleStructOperationInput`.
         597  +
        MissingRequiredBoolean,
         598  +
        /// `required_string` was not provided but it is required when building `SimpleStructOperationInput`.
         599  +
        MissingRequiredString,
         600  +
        /// `required_byte` was not provided but it is required when building `SimpleStructOperationInput`.
         601  +
        MissingRequiredByte,
         602  +
        /// `required_short` was not provided but it is required when building `SimpleStructOperationInput`.
         603  +
        MissingRequiredShort,
         604  +
        /// `required_integer` was not provided but it is required when building `SimpleStructOperationInput`.
         605  +
        MissingRequiredInteger,
         606  +
        /// `required_long` was not provided but it is required when building `SimpleStructOperationInput`.
         607  +
        MissingRequiredLong,
         608  +
        /// `required_float` was not provided but it is required when building `SimpleStructOperationInput`.
         609  +
        MissingRequiredFloat,
         610  +
        /// `required_double` was not provided but it is required when building `SimpleStructOperationInput`.
         611  +
        MissingRequiredDouble,
         612  +
        /// `required_timestamp` was not provided but it is required when building `SimpleStructOperationInput`.
         613  +
        MissingRequiredTimestamp,
         614  +
        /// `required_enum` was not provided but it is required when building `SimpleStructOperationInput`.
         615  +
        MissingRequiredEnum,
         616  +
        /// Constraint violation occurred building member `required_enum` when building `SimpleStructOperationInput`.
         617  +
        #[doc(hidden)]
         618  +
        RequiredEnum(crate::model::suit::ConstraintViolation),
 1002    619   
    }
 1003    620   
    impl ::std::fmt::Display for ConstraintViolation {
 1004    621   
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1005    622   
            match self {
 1006         -
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationInput`"),
         623  +
                ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `SimpleStructOperationInput`"),
         624  +
                ConstraintViolation::MissingRequiredBlob => write!(f, "`required_blob` was not provided but it is required when building `SimpleStructOperationInput`"),
         625  +
                ConstraintViolation::MissingRequiredBoolean => write!(f, "`required_boolean` was not provided but it is required when building `SimpleStructOperationInput`"),
         626  +
                ConstraintViolation::MissingRequiredString => write!(f, "`required_string` was not provided but it is required when building `SimpleStructOperationInput`"),
         627  +
                ConstraintViolation::MissingRequiredByte => write!(f, "`required_byte` was not provided but it is required when building `SimpleStructOperationInput`"),
         628  +
                ConstraintViolation::MissingRequiredShort => write!(f, "`required_short` was not provided but it is required when building `SimpleStructOperationInput`"),
         629  +
                ConstraintViolation::MissingRequiredInteger => write!(f, "`required_integer` was not provided but it is required when building `SimpleStructOperationInput`"),
         630  +
                ConstraintViolation::MissingRequiredLong => write!(f, "`required_long` was not provided but it is required when building `SimpleStructOperationInput`"),
         631  +
                ConstraintViolation::MissingRequiredFloat => write!(f, "`required_float` was not provided but it is required when building `SimpleStructOperationInput`"),
         632  +
                ConstraintViolation::MissingRequiredDouble => write!(f, "`required_double` was not provided but it is required when building `SimpleStructOperationInput`"),
         633  +
                ConstraintViolation::MissingRequiredTimestamp => write!(f, "`required_timestamp` was not provided but it is required when building `SimpleStructOperationInput`"),
         634  +
                ConstraintViolation::MissingRequiredEnum => write!(f, "`required_enum` was not provided but it is required when building `SimpleStructOperationInput`"),
         635  +
                ConstraintViolation::RequiredEnum(_) => write!(f, "constraint violation occurred building member `required_enum` when building `SimpleStructOperationInput`"),
 1007    636   
            }
 1008    637   
        }
 1009    638   
    }
 1010    639   
    impl ::std::error::Error for ConstraintViolation {}
 1011    640   
    impl ConstraintViolation {
 1012    641   
        pub(crate) fn as_validation_exception_field(
 1013    642   
            self,
 1014    643   
            path: ::std::string::String,
 1015    644   
        ) -> crate::model::ValidationExceptionField {
 1016    645   
            match self {
 1017         -
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
 1018         -
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
 1019         -
                                                path: path + "/events",
         646  +
            ConstraintViolation::Enum(inner) => inner.as_validation_exception_field(path + "/enum"),
         647  +
            ConstraintViolation::MissingRequiredBlob => crate::model::ValidationExceptionField {
         648  +
                                                message: format!("Value at '{}/requiredBlob' failed to satisfy constraint: Member must not be null", path),
         649  +
                                                path: path + "/requiredBlob",
         650  +
                                            },
         651  +
            ConstraintViolation::MissingRequiredBoolean => crate::model::ValidationExceptionField {
         652  +
                                                message: format!("Value at '{}/requiredBoolean' failed to satisfy constraint: Member must not be null", path),
         653  +
                                                path: path + "/requiredBoolean",
         654  +
                                            },
         655  +
            ConstraintViolation::MissingRequiredString => crate::model::ValidationExceptionField {
         656  +
                                                message: format!("Value at '{}/requiredString' failed to satisfy constraint: Member must not be null", path),
         657  +
                                                path: path + "/requiredString",
         658  +
                                            },
         659  +
            ConstraintViolation::MissingRequiredByte => crate::model::ValidationExceptionField {
         660  +
                                                message: format!("Value at '{}/requiredByte' failed to satisfy constraint: Member must not be null", path),
         661  +
                                                path: path + "/requiredByte",
         662  +
                                            },
         663  +
            ConstraintViolation::MissingRequiredShort => crate::model::ValidationExceptionField {
         664  +
                                                message: format!("Value at '{}/requiredShort' failed to satisfy constraint: Member must not be null", path),
         665  +
                                                path: path + "/requiredShort",
         666  +
                                            },
         667  +
            ConstraintViolation::MissingRequiredInteger => crate::model::ValidationExceptionField {
         668  +
                                                message: format!("Value at '{}/requiredInteger' failed to satisfy constraint: Member must not be null", path),
         669  +
                                                path: path + "/requiredInteger",
         670  +
                                            },
         671  +
            ConstraintViolation::MissingRequiredLong => crate::model::ValidationExceptionField {
         672  +
                                                message: format!("Value at '{}/requiredLong' failed to satisfy constraint: Member must not be null", path),
         673  +
                                                path: path + "/requiredLong",
         674  +
                                            },
         675  +
            ConstraintViolation::MissingRequiredFloat => crate::model::ValidationExceptionField {
         676  +
                                                message: format!("Value at '{}/requiredFloat' failed to satisfy constraint: Member must not be null", path),
         677  +
                                                path: path + "/requiredFloat",
         678  +
                                            },
         679  +
            ConstraintViolation::MissingRequiredDouble => crate::model::ValidationExceptionField {
         680  +
                                                message: format!("Value at '{}/requiredDouble' failed to satisfy constraint: Member must not be null", path),
         681  +
                                                path: path + "/requiredDouble",
         682  +
                                            },
         683  +
            ConstraintViolation::MissingRequiredTimestamp => crate::model::ValidationExceptionField {
         684  +
                                                message: format!("Value at '{}/requiredTimestamp' failed to satisfy constraint: Member must not be null", path),
         685  +
                                                path: path + "/requiredTimestamp",
         686  +
                                            },
         687  +
            ConstraintViolation::MissingRequiredEnum => crate::model::ValidationExceptionField {
         688  +
                                                message: format!("Value at '{}/requiredEnum' failed to satisfy constraint: Member must not be null", path),
         689  +
                                                path: path + "/requiredEnum",
 1020    690   
                                            },
         691  +
            ConstraintViolation::RequiredEnum(inner) => inner.as_validation_exception_field(path + "/requiredEnum"),
 1021    692   
        }
 1022    693   
        }
 1023    694   
    }
 1024    695   
    impl ::std::convert::From<ConstraintViolation>
 1025    696   
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
 1026    697   
    {
 1027    698   
        fn from(constraint_violation: ConstraintViolation) -> Self {
 1028    699   
            let first_validation_exception_field =
 1029    700   
                constraint_violation.as_validation_exception_field("".to_owned());
 1030    701   
            let validation_exception = crate::error::ValidationException {
 1031    702   
                message: format!(
 1032    703   
                    "1 validation error detected. {}",
 1033    704   
                    &first_validation_exception_field.message
 1034    705   
                ),
 1035    706   
                field_list: Some(vec![first_validation_exception_field]),
 1036    707   
            };
 1037    708   
            Self::ConstraintViolation(
 1038    709   
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
 1039    710   
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
 1040    711   
                            )
 1041    712   
        }
 1042    713   
    }
 1043    714   
    impl ::std::convert::From<Builder>
 1044         -
        for crate::constrained::MaybeConstrained<crate::input::StreamingOperationInput>
         715  +
        for crate::constrained::MaybeConstrained<crate::input::SimpleStructOperationInput>
 1045    716   
    {
 1046    717   
        fn from(builder: Builder) -> Self {
 1047    718   
            Self::Unconstrained(builder)
 1048    719   
        }
 1049    720   
    }
 1050         -
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationInput {
         721  +
    impl ::std::convert::TryFrom<Builder> for crate::input::SimpleStructOperationInput {
 1051    722   
        type Error = ConstraintViolation;
 1052    723   
 1053    724   
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
 1054    725   
            builder.build()
 1055    726   
        }
 1056    727   
    }
 1057         -
    /// A builder for [`StreamingOperationInput`](crate::input::StreamingOperationInput).
 1058         -
    #[derive(::std::default::Default, ::std::fmt::Debug)]
         728  +
    /// A builder for [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
         729  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 1059    730   
    pub struct Builder {
 1060         -
        pub(crate) events: ::std::option::Option<
 1061         -
            crate::sigv4_event_stream::SigV4Receiver<
 1062         -
                crate::model::Events,
 1063         -
                ::aws_smithy_http::event_stream::MessageStreamError,
 1064         -
            >,
 1065         -
        >,
         731  +
        pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
         732  +
        pub(crate) boolean: ::std::option::Option<bool>,
         733  +
        pub(crate) string: ::std::option::Option<::std::string::String>,
         734  +
        pub(crate) byte: ::std::option::Option<i8>,
         735  +
        pub(crate) short: ::std::option::Option<i16>,
         736  +
        pub(crate) integer: ::std::option::Option<i32>,
         737  +
        pub(crate) long: ::std::option::Option<i64>,
         738  +
        pub(crate) float: ::std::option::Option<f32>,
         739  +
        pub(crate) double: ::std::option::Option<f64>,
         740  +
        pub(crate) timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
         741  +
        pub(crate) r#enum:
         742  +
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
         743  +
        pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
         744  +
        pub(crate) required_boolean: ::std::option::Option<bool>,
         745  +
        pub(crate) required_string: ::std::option::Option<::std::string::String>,
         746  +
        pub(crate) required_byte: ::std::option::Option<i8>,
         747  +
        pub(crate) required_short: ::std::option::Option<i16>,
         748  +
        pub(crate) required_integer: ::std::option::Option<i32>,
         749  +
        pub(crate) required_long: ::std::option::Option<i64>,
         750  +
        pub(crate) required_float: ::std::option::Option<f32>,
         751  +
        pub(crate) required_double: ::std::option::Option<f64>,
         752  +
        pub(crate) required_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
         753  +
        pub(crate) required_enum:
         754  +
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 1066    755   
    }
 1067    756   
    impl Builder {
 1068    757   
        #[allow(missing_docs)] // documentation missing in model
 1069         -
        pub fn events(
         758  +
        pub fn blob(mut self, input: ::std::option::Option<::aws_smithy_types::Blob>) -> Self {
         759  +
            self.blob = input;
         760  +
            self
         761  +
        }
         762  +
        #[allow(missing_docs)] // documentation missing in model
         763  +
        pub(crate) fn set_blob(
 1070    764   
            mut self,
 1071         -
            input: crate::sigv4_event_stream::SigV4Receiver<
 1072         -
                crate::model::Events,
 1073         -
                ::aws_smithy_http::event_stream::MessageStreamError,
         765  +
            input: Option<impl ::std::convert::Into<::aws_smithy_types::Blob>>,
         766  +
        ) -> Self {
         767  +
            self.blob = input.map(|v| v.into());
         768  +
            self
         769  +
        }
         770  +
        #[allow(missing_docs)] // documentation missing in model
         771  +
        pub fn boolean(mut self, input: ::std::option::Option<bool>) -> Self {
         772  +
            self.boolean = input;
         773  +
            self
         774  +
        }
         775  +
        #[allow(missing_docs)] // documentation missing in model
         776  +
        pub(crate) fn set_boolean(
         777  +
            mut self,
         778  +
            input: Option<impl ::std::convert::Into<bool>>,
         779  +
        ) -> Self {
         780  +
            self.boolean = input.map(|v| v.into());
         781  +
            self
         782  +
        }
         783  +
        #[allow(missing_docs)] // documentation missing in model
         784  +
        pub fn string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         785  +
            self.string = input;
         786  +
            self
         787  +
        }
         788  +
        #[allow(missing_docs)] // documentation missing in model
         789  +
        pub(crate) fn set_string(
         790  +
            mut self,
         791  +
            input: Option<impl ::std::convert::Into<::std::string::String>>,
         792  +
        ) -> Self {
         793  +
            self.string = input.map(|v| v.into());
         794  +
            self
         795  +
        }
         796  +
        #[allow(missing_docs)] // documentation missing in model
         797  +
        pub fn byte(mut self, input: ::std::option::Option<i8>) -> Self {
         798  +
            self.byte = input;
         799  +
            self
         800  +
        }
         801  +
        #[allow(missing_docs)] // documentation missing in model
         802  +
        pub(crate) fn set_byte(mut self, input: Option<impl ::std::convert::Into<i8>>) -> Self {
         803  +
            self.byte = input.map(|v| v.into());
         804  +
            self
         805  +
        }
         806  +
        #[allow(missing_docs)] // documentation missing in model
         807  +
        pub fn short(mut self, input: ::std::option::Option<i16>) -> Self {
         808  +
            self.short = input;
         809  +
            self
         810  +
        }
         811  +
        #[allow(missing_docs)] // documentation missing in model
         812  +
        pub(crate) fn set_short(mut self, input: Option<impl ::std::convert::Into<i16>>) -> Self {
         813  +
            self.short = input.map(|v| v.into());
         814  +
            self
         815  +
        }
         816  +
        #[allow(missing_docs)] // documentation missing in model
         817  +
        pub fn integer(mut self, input: ::std::option::Option<i32>) -> Self {
         818  +
            self.integer = input;
         819  +
            self
         820  +
        }
         821  +
        #[allow(missing_docs)] // documentation missing in model
         822  +
        pub(crate) fn set_integer(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
         823  +
            self.integer = input.map(|v| v.into());
         824  +
            self
         825  +
        }
         826  +
        #[allow(missing_docs)] // documentation missing in model
         827  +
        pub fn long(mut self, input: ::std::option::Option<i64>) -> Self {
         828  +
            self.long = input;
         829  +
            self
         830  +
        }
         831  +
        #[allow(missing_docs)] // documentation missing in model
         832  +
        pub(crate) fn set_long(mut self, input: Option<impl ::std::convert::Into<i64>>) -> Self {
         833  +
            self.long = input.map(|v| v.into());
         834  +
            self
         835  +
        }
         836  +
        #[allow(missing_docs)] // documentation missing in model
         837  +
        pub fn float(mut self, input: ::std::option::Option<f32>) -> Self {
         838  +
            self.float = input;
         839  +
            self
         840  +
        }
         841  +
        #[allow(missing_docs)] // documentation missing in model
         842  +
        pub(crate) fn set_float(mut self, input: Option<impl ::std::convert::Into<f32>>) -> Self {
         843  +
            self.float = input.map(|v| v.into());
         844  +
            self
         845  +
        }
         846  +
        #[allow(missing_docs)] // documentation missing in model
         847  +
        pub fn double(mut self, input: ::std::option::Option<f64>) -> Self {
         848  +
            self.double = input;
         849  +
            self
         850  +
        }
         851  +
        #[allow(missing_docs)] // documentation missing in model
         852  +
        pub(crate) fn set_double(mut self, input: Option<impl ::std::convert::Into<f64>>) -> Self {
         853  +
            self.double = input.map(|v| v.into());
         854  +
            self
         855  +
        }
         856  +
        #[allow(missing_docs)] // documentation missing in model
         857  +
        pub fn timestamp(
         858  +
            mut self,
         859  +
            input: ::std::option::Option<::aws_smithy_types::DateTime>,
         860  +
        ) -> Self {
         861  +
            self.timestamp = input;
         862  +
            self
         863  +
        }
         864  +
        #[allow(missing_docs)] // documentation missing in model
         865  +
        pub(crate) fn set_timestamp(
         866  +
            mut self,
         867  +
            input: Option<impl ::std::convert::Into<::aws_smithy_types::DateTime>>,
         868  +
        ) -> Self {
         869  +
            self.timestamp = input.map(|v| v.into());
         870  +
            self
         871  +
        }
         872  +
        #[allow(missing_docs)] // documentation missing in model
         873  +
        pub fn r#enum(mut self, input: ::std::option::Option<crate::model::Suit>) -> Self {
         874  +
            self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
         875  +
            self
         876  +
        }
         877  +
        #[allow(missing_docs)] // documentation missing in model
         878  +
        pub(crate) fn set_enum(
         879  +
            mut self,
         880  +
            input: Option<
         881  +
                impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 1074    882   
            >,
 1075    883   
        ) -> Self {
 1076         -
            self.events = Some(input);
         884  +
            self.r#enum = input.map(|v| v.into());
         885  +
            self
         886  +
        }
         887  +
        #[allow(missing_docs)] // documentation missing in model
         888  +
        pub fn required_blob(mut self, input: ::aws_smithy_types::Blob) -> Self {
         889  +
            self.required_blob = Some(input);
         890  +
            self
         891  +
        }
         892  +
        #[allow(missing_docs)] // documentation missing in model
         893  +
        pub(crate) fn set_required_blob(
         894  +
            mut self,
         895  +
            input: impl ::std::convert::Into<::aws_smithy_types::Blob>,
         896  +
        ) -> Self {
         897  +
            self.required_blob = Some(input.into());
         898  +
            self
         899  +
        }
         900  +
        #[allow(missing_docs)] // documentation missing in model
         901  +
        pub fn required_boolean(mut self, input: bool) -> Self {
         902  +
            self.required_boolean = Some(input);
         903  +
            self
         904  +
        }
         905  +
        #[allow(missing_docs)] // documentation missing in model
         906  +
        pub(crate) fn set_required_boolean(
         907  +
            mut self,
         908  +
            input: impl ::std::convert::Into<bool>,
         909  +
        ) -> Self {
         910  +
            self.required_boolean = Some(input.into());
         911  +
            self
         912  +
        }
         913  +
        #[allow(missing_docs)] // documentation missing in model
         914  +
        pub fn required_string(mut self, input: ::std::string::String) -> Self {
         915  +
            self.required_string = Some(input);
         916  +
            self
         917  +
        }
         918  +
        #[allow(missing_docs)] // documentation missing in model
         919  +
        pub(crate) fn set_required_string(
         920  +
            mut self,
         921  +
            input: impl ::std::convert::Into<::std::string::String>,
         922  +
        ) -> Self {
         923  +
            self.required_string = Some(input.into());
 1077    924   
            self
 1078    925   
        }
 1079    926   
        #[allow(missing_docs)] // documentation missing in model
 1080         -
        pub(crate) fn set_events(
 1081         -
            mut self,
 1082         -
            input: impl ::std::convert::Into<
 1083         -
                crate::sigv4_event_stream::SigV4Receiver<
 1084         -
                    crate::model::Events,
 1085         -
                    ::aws_smithy_http::event_stream::MessageStreamError,
 1086         -
                >,
 1087         -
            >,
 1088         -
        ) -> Self {
 1089         -
            self.events = Some(input.into());
         927  +
        pub fn required_byte(mut self, input: i8) -> Self {
         928  +
            self.required_byte = Some(input);
 1090    929   
            self
 1091    930   
        }
 1092         -
        /// Consumes the builder and constructs a [`StreamingOperationInput`](crate::input::StreamingOperationInput).
 1093         -
        ///
 1094         -
        /// The builder fails to construct a [`StreamingOperationInput`](crate::input::StreamingOperationInput) if a [`ConstraintViolation`] occurs.
 1095         -
        ///
 1096         -
        pub fn build(self) -> Result<crate::input::StreamingOperationInput, ConstraintViolation> {
 1097         -
            self.build_enforcing_all_constraints()
         931  +
        #[allow(missing_docs)] // documentation missing in model
         932  +
        pub(crate) fn set_required_byte(mut self, input: impl ::std::convert::Into<i8>) -> Self {
         933  +
            self.required_byte = Some(input.into());
         934  +
            self
 1098    935   
        }
 1099         -
        fn build_enforcing_all_constraints(
 1100         -
            self,
 1101         -
        ) -> Result<crate::input::StreamingOperationInput, ConstraintViolation> {
 1102         -
            Ok(crate::input::StreamingOperationInput {
 1103         -
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
 1104         -
            })
         936  +
        #[allow(missing_docs)] // documentation missing in model
         937  +
        pub fn required_short(mut self, input: i16) -> Self {
         938  +
            self.required_short = Some(input);
         939  +
            self
 1105    940   
        }
 1106         -
    }
 1107         -
}
 1108         -
/// See [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
 1109         -
pub mod recursive_union_operation_input {
 1110         -
 1111         -
    impl ::std::convert::From<Builder> for crate::input::RecursiveUnionOperationInput {
 1112         -
        fn from(builder: Builder) -> Self {
 1113         -
            builder.build()
         941  +
        #[allow(missing_docs)] // documentation missing in model
         942  +
        pub(crate) fn set_required_short(mut self, input: impl ::std::convert::Into<i16>) -> Self {
         943  +
            self.required_short = Some(input.into());
         944  +
            self
 1114    945   
        }
 1115         -
    }
 1116         -
    /// A builder for [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
 1117         -
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 1118         -
    pub struct Builder {
 1119         -
        pub(crate) nested:
 1120         -
            ::std::option::Option<crate::model::RecursiveOperationInputOutputNested1>,
 1121         -
    }
 1122         -
    impl Builder {
 1123    946   
        #[allow(missing_docs)] // documentation missing in model
 1124         -
        pub fn nested(
 1125         -
            mut self,
 1126         -
            input: ::std::option::Option<crate::model::RecursiveOperationInputOutputNested1>,
 1127         -
        ) -> Self {
 1128         -
            self.nested = input;
         947  +
        pub fn required_integer(mut self, input: i32) -> Self {
         948  +
            self.required_integer = Some(input);
 1129    949   
            self
 1130    950   
        }
 1131    951   
        #[allow(missing_docs)] // documentation missing in model
 1132         -
        pub(crate) fn set_nested(
         952  +
        pub(crate) fn set_required_integer(
 1133    953   
            mut self,
 1134         -
            input: Option<
 1135         -
                impl ::std::convert::Into<crate::model::RecursiveOperationInputOutputNested1>,
 1136         -
            >,
         954  +
            input: impl ::std::convert::Into<i32>,
 1137    955   
        ) -> Self {
 1138         -
            self.nested = input.map(|v| v.into());
         956  +
            self.required_integer = Some(input.into());
 1139    957   
            self
 1140    958   
        }
 1141         -
        /// Consumes the builder and constructs a [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
 1142         -
        pub fn build(self) -> crate::input::RecursiveUnionOperationInput {
 1143         -
            self.build_enforcing_all_constraints()
         959  +
        #[allow(missing_docs)] // documentation missing in model
         960  +
        pub fn required_long(mut self, input: i64) -> Self {
         961  +
            self.required_long = Some(input);
         962  +
            self
 1144    963   
        }
 1145         -
        fn build_enforcing_all_constraints(self) -> crate::input::RecursiveUnionOperationInput {
 1146         -
            crate::input::RecursiveUnionOperationInput {
 1147         -
                nested: self.nested,
 1148         -
            }
         964  +
        #[allow(missing_docs)] // documentation missing in model
         965  +
        pub(crate) fn set_required_long(mut self, input: impl ::std::convert::Into<i64>) -> Self {
         966  +
            self.required_long = Some(input.into());
         967  +
            self
 1149    968   
        }
 1150         -
    }
 1151         -
}
 1152         -
/// See [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
 1153         -
pub mod single_member_struct_operation_input {
 1154         -
 1155         -
    impl ::std::convert::From<Builder> for crate::input::SingleMemberStructOperationInput {
 1156         -
        fn from(builder: Builder) -> Self {
 1157         -
            builder.build()
         969  +
        #[allow(missing_docs)] // documentation missing in model
         970  +
        pub fn required_float(mut self, input: f32) -> Self {
         971  +
            self.required_float = Some(input);
         972  +
            self
 1158    973   
        }
 1159         -
    }
 1160         -
    /// A builder for [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
 1161         -
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 1162         -
    pub struct Builder {
 1163         -
        pub(crate) message: ::std::option::Option<::std::string::String>,
 1164         -
    }
 1165         -
    impl Builder {
 1166    974   
        #[allow(missing_docs)] // documentation missing in model
 1167         -
        pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
 1168         -
            self.message = input;
         975  +
        pub(crate) fn set_required_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
         976  +
            self.required_float = Some(input.into());
 1169    977   
            self
 1170    978   
        }
 1171    979   
        #[allow(missing_docs)] // documentation missing in model
 1172         -
        pub(crate) fn set_message(
         980  +
        pub fn required_double(mut self, input: f64) -> Self {
         981  +
            self.required_double = Some(input);
         982  +
            self
         983  +
        }
         984  +
        #[allow(missing_docs)] // documentation missing in model
         985  +
        pub(crate) fn set_required_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
         986  +
            self.required_double = Some(input.into());
         987  +
            self
         988  +
        }
         989  +
        #[allow(missing_docs)] // documentation missing in model
         990  +
        pub fn required_timestamp(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         991  +
            self.required_timestamp = Some(input);
         992  +
            self
         993  +
        }
         994  +
        #[allow(missing_docs)] // documentation missing in model
         995  +
        pub(crate) fn set_required_timestamp(
 1173    996   
            mut self,
 1174         -
            input: Option<impl ::std::convert::Into<::std::string::String>>,
         997  +
            input: impl ::std::convert::Into<::aws_smithy_types::DateTime>,
 1175    998   
        ) -> Self {
 1176         -
            self.message = input.map(|v| v.into());
         999  +
            self.required_timestamp = Some(input.into());
 1177   1000   
            self
 1178   1001   
        }
 1179         -
        /// Consumes the builder and constructs a [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
 1180         -
        pub fn build(self) -> crate::input::SingleMemberStructOperationInput {
 1181         -
            self.build_enforcing_all_constraints()
 1182         -
        }
 1183         -
        fn build_enforcing_all_constraints(self) -> crate::input::SingleMemberStructOperationInput {
 1184         -
            crate::input::SingleMemberStructOperationInput {
 1185         -
                message: self.message,
 1186         -
            }
        1002  +
        #[allow(missing_docs)] // documentation missing in model
        1003  +
        pub fn required_enum(mut self, input: crate::model::Suit) -> Self {
        1004  +
            self.required_enum = Some(crate::constrained::MaybeConstrained::Constrained(input));
        1005  +
            self
 1187   1006   
        }
 1188         -
    }
 1189         -
}
 1190         -
/// See [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
 1191         -
pub mod empty_struct_operation_input {
 1192         -
 1193         -
    impl ::std::convert::From<Builder> for crate::input::EmptyStructOperationInput {
 1194         -
        fn from(builder: Builder) -> Self {
 1195         -
            builder.build()
        1007  +
        #[allow(missing_docs)] // documentation missing in model
        1008  +
        pub(crate) fn set_required_enum(
        1009  +
            mut self,
        1010  +
            input: impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        1011  +
        ) -> Self {
        1012  +
            self.required_enum = Some(input.into());
        1013  +
            self
 1196   1014   
        }
 1197         -
    }
 1198         -
    /// A builder for [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
 1199         -
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 1200         -
    pub struct Builder {}
 1201         -
    impl Builder {
 1202         -
        /// Consumes the builder and constructs a [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
 1203         -
        pub fn build(self) -> crate::input::EmptyStructOperationInput {
        1015  +
        /// Consumes the builder and constructs a [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
        1016  +
        ///
        1017  +
        /// The builder fails to construct a [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput) if a [`ConstraintViolation`] occurs.
        1018  +
        ///
        1019  +
        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
        1020  +
        pub fn build(
        1021  +
            self,
        1022  +
        ) -> Result<crate::input::SimpleStructOperationInput, ConstraintViolation> {
 1204   1023   
            self.build_enforcing_all_constraints()
 1205   1024   
        }
 1206         -
        fn build_enforcing_all_constraints(self) -> crate::input::EmptyStructOperationInput {
 1207         -
            crate::input::EmptyStructOperationInput {}
        1025  +
        fn build_enforcing_all_constraints(
        1026  +
            self,
        1027  +
        ) -> Result<crate::input::SimpleStructOperationInput, ConstraintViolation> {
        1028  +
            Ok(crate::input::SimpleStructOperationInput {
        1029  +
                blob: self.blob,
        1030  +
                boolean: self.boolean,
        1031  +
                string: self.string,
        1032  +
                byte: self.byte,
        1033  +
                short: self.short,
        1034  +
                integer: self.integer,
        1035  +
                long: self.long,
        1036  +
                float: self.float,
        1037  +
                double: self.double,
        1038  +
                timestamp: self.timestamp,
        1039  +
                r#enum: self
        1040  +
                    .r#enum
        1041  +
                    .map(|v| match v {
        1042  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
        1043  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
        1044  +
                    })
        1045  +
                    .map(|res| res.map_err(ConstraintViolation::Enum))
        1046  +
                    .transpose()?,
        1047  +
                required_blob: self
        1048  +
                    .required_blob
        1049  +
                    .ok_or(ConstraintViolation::MissingRequiredBlob)?,
        1050  +
                required_boolean: self
        1051  +
                    .required_boolean
        1052  +
                    .ok_or(ConstraintViolation::MissingRequiredBoolean)?,
        1053  +
                required_string: self
        1054  +
                    .required_string
        1055  +
                    .ok_or(ConstraintViolation::MissingRequiredString)?,
        1056  +
                required_byte: self
        1057  +
                    .required_byte
        1058  +
                    .ok_or(ConstraintViolation::MissingRequiredByte)?,
        1059  +
                required_short: self
        1060  +
                    .required_short
        1061  +
                    .ok_or(ConstraintViolation::MissingRequiredShort)?,
        1062  +
                required_integer: self
        1063  +
                    .required_integer
        1064  +
                    .ok_or(ConstraintViolation::MissingRequiredInteger)?,
        1065  +
                required_long: self
        1066  +
                    .required_long
        1067  +
                    .ok_or(ConstraintViolation::MissingRequiredLong)?,
        1068  +
                required_float: self
        1069  +
                    .required_float
        1070  +
                    .ok_or(ConstraintViolation::MissingRequiredFloat)?,
        1071  +
                required_double: self
        1072  +
                    .required_double
        1073  +
                    .ok_or(ConstraintViolation::MissingRequiredDouble)?,
        1074  +
                required_timestamp: self
        1075  +
                    .required_timestamp
        1076  +
                    .ok_or(ConstraintViolation::MissingRequiredTimestamp)?,
        1077  +
                required_enum: self
        1078  +
                    .required_enum
        1079  +
                    .map(|v| match v {
        1080  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
        1081  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
        1082  +
                    })
        1083  +
                    .map(|res| res.map_err(ConstraintViolation::RequiredEnum))
        1084  +
                    .transpose()?
        1085  +
                    .ok_or(ConstraintViolation::MissingRequiredEnum)?,
        1086  +
            })
 1208   1087   
        }
 1209   1088   
    }
 1210   1089   
}
 1211         -
/// See [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
 1212         -
pub mod complex_struct_operation_input {
        1090  +
/// See [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
        1091  +
pub mod error_serialization_operation_input {
 1213   1092   
 1214   1093   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
 1215   1094   
    /// Holds one variant for each of the ways the builder can fail.
 1216   1095   
    #[non_exhaustive]
 1217   1096   
    #[allow(clippy::enum_variant_names)]
 1218   1097   
    pub enum ConstraintViolation {
 1219         -
        /// Constraint violation occurred building member `structure` when building `ComplexStructOperationInput`.
 1220         -
        #[doc(hidden)]
 1221         -
        Structure(crate::model::simple_struct::ConstraintViolation),
 1222         -
        /// Constraint violation occurred building member `structure_list` when building `ComplexStructOperationInput`.
 1223         -
        #[doc(hidden)]
 1224         -
        StructureList(crate::model::struct_list::ConstraintViolation),
 1225         -
        /// `complex_list` was not provided but it is required when building `ComplexStructOperationInput`.
 1226         -
        MissingComplexList,
 1227         -
        /// Constraint violation occurred building member `complex_list` when building `ComplexStructOperationInput`.
 1228         -
        #[doc(hidden)]
 1229         -
        ComplexList(crate::model::complex_list::ConstraintViolation),
 1230         -
        /// `complex_map` was not provided but it is required when building `ComplexStructOperationInput`.
 1231         -
        MissingComplexMap,
 1232         -
        /// Constraint violation occurred building member `complex_map` when building `ComplexStructOperationInput`.
        1098  +
        /// Constraint violation occurred building member `r#enum` when building `ErrorSerializationOperationInput`.
 1233   1099   
        #[doc(hidden)]
 1234         -
        ComplexMap(crate::model::complex_map::ConstraintViolation),
 1235         -
        /// `complex_union` was not provided but it is required when building `ComplexStructOperationInput`.
 1236         -
        MissingComplexUnion,
 1237         -
        /// Constraint violation occurred building member `complex_union` when building `ComplexStructOperationInput`.
        1100  +
        Enum(crate::model::suit::ConstraintViolation),
        1101  +
        /// `required_blob` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1102  +
        MissingRequiredBlob,
        1103  +
        /// `required_boolean` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1104  +
        MissingRequiredBoolean,
        1105  +
        /// `required_string` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1106  +
        MissingRequiredString,
        1107  +
        /// `required_byte` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1108  +
        MissingRequiredByte,
        1109  +
        /// `required_short` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1110  +
        MissingRequiredShort,
        1111  +
        /// `required_integer` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1112  +
        MissingRequiredInteger,
        1113  +
        /// `required_long` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1114  +
        MissingRequiredLong,
        1115  +
        /// `required_float` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1116  +
        MissingRequiredFloat,
        1117  +
        /// `required_double` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1118  +
        MissingRequiredDouble,
        1119  +
        /// `required_timestamp` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1120  +
        MissingRequiredTimestamp,
        1121  +
        /// `required_enum` was not provided but it is required when building `ErrorSerializationOperationInput`.
        1122  +
        MissingRequiredEnum,
        1123  +
        /// Constraint violation occurred building member `required_enum` when building `ErrorSerializationOperationInput`.
 1238   1124   
        #[doc(hidden)]
 1239         -
        ComplexUnion(::std::boxed::Box<crate::model::complex_union::ConstraintViolation>),
        1125  +
        RequiredEnum(crate::model::suit::ConstraintViolation),
 1240   1126   
    }
 1241   1127   
    impl ::std::fmt::Display for ConstraintViolation {
 1242   1128   
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1243   1129   
            match self {
 1244         -
                ConstraintViolation::Structure(_) => write!(f, "constraint violation occurred building member `structure` when building `ComplexStructOperationInput`"),
 1245         -
                ConstraintViolation::StructureList(_) => write!(f, "constraint violation occurred building member `structure_list` when building `ComplexStructOperationInput`"),
 1246         -
                ConstraintViolation::MissingComplexList => write!(f, "`complex_list` was not provided but it is required when building `ComplexStructOperationInput`"),
 1247         -
                ConstraintViolation::ComplexList(_) => write!(f, "constraint violation occurred building member `complex_list` when building `ComplexStructOperationInput`"),
 1248         -
                ConstraintViolation::MissingComplexMap => write!(f, "`complex_map` was not provided but it is required when building `ComplexStructOperationInput`"),
 1249         -
                ConstraintViolation::ComplexMap(_) => write!(f, "constraint violation occurred building member `complex_map` when building `ComplexStructOperationInput`"),
 1250         -
                ConstraintViolation::MissingComplexUnion => write!(f, "`complex_union` was not provided but it is required when building `ComplexStructOperationInput`"),
 1251         -
                ConstraintViolation::ComplexUnion(_) => write!(f, "constraint violation occurred building member `complex_union` when building `ComplexStructOperationInput`"),
        1130  +
                ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `ErrorSerializationOperationInput`"),
        1131  +
                ConstraintViolation::MissingRequiredBlob => write!(f, "`required_blob` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1132  +
                ConstraintViolation::MissingRequiredBoolean => write!(f, "`required_boolean` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1133  +
                ConstraintViolation::MissingRequiredString => write!(f, "`required_string` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1134  +
                ConstraintViolation::MissingRequiredByte => write!(f, "`required_byte` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1135  +
                ConstraintViolation::MissingRequiredShort => write!(f, "`required_short` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1136  +
                ConstraintViolation::MissingRequiredInteger => write!(f, "`required_integer` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1137  +
                ConstraintViolation::MissingRequiredLong => write!(f, "`required_long` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1138  +
                ConstraintViolation::MissingRequiredFloat => write!(f, "`required_float` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1139  +
                ConstraintViolation::MissingRequiredDouble => write!(f, "`required_double` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1140  +
                ConstraintViolation::MissingRequiredTimestamp => write!(f, "`required_timestamp` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1141  +
                ConstraintViolation::MissingRequiredEnum => write!(f, "`required_enum` was not provided but it is required when building `ErrorSerializationOperationInput`"),
        1142  +
                ConstraintViolation::RequiredEnum(_) => write!(f, "constraint violation occurred building member `required_enum` when building `ErrorSerializationOperationInput`"),
 1252   1143   
            }
 1253   1144   
        }
 1254   1145   
    }
 1255   1146   
    impl ::std::error::Error for ConstraintViolation {}
 1256   1147   
    impl ConstraintViolation {
 1257   1148   
        pub(crate) fn as_validation_exception_field(
 1258   1149   
            self,
 1259   1150   
            path: ::std::string::String,
 1260   1151   
        ) -> crate::model::ValidationExceptionField {
 1261   1152   
            match self {
 1262         -
            ConstraintViolation::Structure(inner) => inner.as_validation_exception_field(path + "/structure"),
 1263         -
            ConstraintViolation::StructureList(inner) => inner.as_validation_exception_field(path + "/structureList"),
 1264         -
            ConstraintViolation::MissingComplexList => crate::model::ValidationExceptionField {
 1265         -
                                                message: format!("Value at '{}/complexList' failed to satisfy constraint: Member must not be null", path),
 1266         -
                                                path: path + "/complexList",
        1153  +
            ConstraintViolation::Enum(inner) => inner.as_validation_exception_field(path + "/enum"),
        1154  +
            ConstraintViolation::MissingRequiredBlob => crate::model::ValidationExceptionField {
        1155  +
                                                message: format!("Value at '{}/requiredBlob' failed to satisfy constraint: Member must not be null", path),
        1156  +
                                                path: path + "/requiredBlob",
 1267   1157   
                                            },
 1268         -
            ConstraintViolation::ComplexList(inner) => inner.as_validation_exception_field(path + "/complexList"),
 1269         -
            ConstraintViolation::MissingComplexMap => crate::model::ValidationExceptionField {
 1270         -
                                                message: format!("Value at '{}/complexMap' failed to satisfy constraint: Member must not be null", path),
 1271         -
                                                path: path + "/complexMap",
        1158  +
            ConstraintViolation::MissingRequiredBoolean => crate::model::ValidationExceptionField {
        1159  +
                                                message: format!("Value at '{}/requiredBoolean' failed to satisfy constraint: Member must not be null", path),
        1160  +
                                                path: path + "/requiredBoolean",
 1272   1161   
                                            },
 1273         -
            ConstraintViolation::ComplexMap(inner) => inner.as_validation_exception_field(path + "/complexMap"),
 1274         -
            ConstraintViolation::MissingComplexUnion => crate::model::ValidationExceptionField {
 1275         -
                                                message: format!("Value at '{}/complexUnion' failed to satisfy constraint: Member must not be null", path),
 1276         -
                                                path: path + "/complexUnion",
        1162  +
            ConstraintViolation::MissingRequiredString => crate::model::ValidationExceptionField {
        1163  +
                                                message: format!("Value at '{}/requiredString' failed to satisfy constraint: Member must not be null", path),
        1164  +
                                                path: path + "/requiredString",
 1277   1165   
                                            },
 1278         -
            ConstraintViolation::ComplexUnion(inner) => inner.as_validation_exception_field(path + "/complexUnion"),
        1166  +
            ConstraintViolation::MissingRequiredByte => crate::model::ValidationExceptionField {
        1167  +
                                                message: format!("Value at '{}/requiredByte' failed to satisfy constraint: Member must not be null", path),
        1168  +
                                                path: path + "/requiredByte",
        1169  +
                                            },
        1170  +
            ConstraintViolation::MissingRequiredShort => crate::model::ValidationExceptionField {
        1171  +
                                                message: format!("Value at '{}/requiredShort' failed to satisfy constraint: Member must not be null", path),
        1172  +
                                                path: path + "/requiredShort",
        1173  +
                                            },
        1174  +
            ConstraintViolation::MissingRequiredInteger => crate::model::ValidationExceptionField {
        1175  +
                                                message: format!("Value at '{}/requiredInteger' failed to satisfy constraint: Member must not be null", path),
        1176  +
                                                path: path + "/requiredInteger",
        1177  +
                                            },
        1178  +
            ConstraintViolation::MissingRequiredLong => crate::model::ValidationExceptionField {
        1179  +
                                                message: format!("Value at '{}/requiredLong' failed to satisfy constraint: Member must not be null", path),
        1180  +
                                                path: path + "/requiredLong",
        1181  +
                                            },
        1182  +
            ConstraintViolation::MissingRequiredFloat => crate::model::ValidationExceptionField {
        1183  +
                                                message: format!("Value at '{}/requiredFloat' failed to satisfy constraint: Member must not be null", path),
        1184  +
                                                path: path + "/requiredFloat",
        1185  +
                                            },
        1186  +
            ConstraintViolation::MissingRequiredDouble => crate::model::ValidationExceptionField {
        1187  +
                                                message: format!("Value at '{}/requiredDouble' failed to satisfy constraint: Member must not be null", path),
        1188  +
                                                path: path + "/requiredDouble",
        1189  +
                                            },
        1190  +
            ConstraintViolation::MissingRequiredTimestamp => crate::model::ValidationExceptionField {
        1191  +
                                                message: format!("Value at '{}/requiredTimestamp' failed to satisfy constraint: Member must not be null", path),
        1192  +
                                                path: path + "/requiredTimestamp",
        1193  +
                                            },
        1194  +
            ConstraintViolation::MissingRequiredEnum => crate::model::ValidationExceptionField {
        1195  +
                                                message: format!("Value at '{}/requiredEnum' failed to satisfy constraint: Member must not be null", path),
        1196  +
                                                path: path + "/requiredEnum",
        1197  +
                                            },
        1198  +
            ConstraintViolation::RequiredEnum(inner) => inner.as_validation_exception_field(path + "/requiredEnum"),
 1279   1199   
        }
 1280   1200   
        }
 1281   1201   
    }
 1282   1202   
    impl ::std::convert::From<ConstraintViolation>
 1283   1203   
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
 1284   1204   
    {
 1285   1205   
        fn from(constraint_violation: ConstraintViolation) -> Self {
 1286   1206   
            let first_validation_exception_field =
 1287   1207   
                constraint_violation.as_validation_exception_field("".to_owned());
 1288   1208   
            let validation_exception = crate::error::ValidationException {
 1289   1209   
                message: format!(
 1290   1210   
                    "1 validation error detected. {}",
 1291   1211   
                    &first_validation_exception_field.message
 1292   1212   
                ),
 1293   1213   
                field_list: Some(vec![first_validation_exception_field]),
 1294   1214   
            };
 1295   1215   
            Self::ConstraintViolation(
 1296   1216   
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
 1297   1217   
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
 1298   1218   
                            )
 1299   1219   
        }
 1300   1220   
    }
 1301   1221   
    impl ::std::convert::From<Builder>
 1302         -
        for crate::constrained::MaybeConstrained<crate::input::ComplexStructOperationInput>
        1222  +
        for crate::constrained::MaybeConstrained<crate::input::ErrorSerializationOperationInput>
 1303   1223   
    {
 1304   1224   
        fn from(builder: Builder) -> Self {
 1305   1225   
            Self::Unconstrained(builder)
 1306   1226   
        }
 1307   1227   
    }
 1308         -
    impl ::std::convert::TryFrom<Builder> for crate::input::ComplexStructOperationInput {
        1228  +
    impl ::std::convert::TryFrom<Builder> for crate::input::ErrorSerializationOperationInput {
 1309   1229   
        type Error = ConstraintViolation;
 1310   1230   
 1311   1231   
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
 1312   1232   
            builder.build()
 1313   1233   
        }
 1314   1234   
    }
 1315         -
    /// A builder for [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
        1235  +
    /// A builder for [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
 1316   1236   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 1317   1237   
    pub struct Builder {
 1318         -
        pub(crate) structure:
 1319         -
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SimpleStruct>>,
 1320         -
        pub(crate) empty_structure: ::std::option::Option<crate::model::EmptyStruct>,
 1321         -
        pub(crate) list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
 1322         -
        pub(crate) map:
 1323         -
            ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
 1324         -
        pub(crate) union: ::std::option::Option<crate::model::SimpleUnion>,
 1325         -
        pub(crate) unit_union: ::std::option::Option<crate::model::UnitUnion>,
 1326         -
        pub(crate) structure_list: ::std::option::Option<
 1327         -
            crate::constrained::MaybeConstrained<
 1328         -
                crate::constrained::struct_list_constrained::StructListConstrained,
 1329         -
            >,
 1330         -
        >,
 1331         -
        pub(crate) complex_list: ::std::option::Option<
 1332         -
            crate::constrained::MaybeConstrained<
 1333         -
                crate::constrained::complex_list_constrained::ComplexListConstrained,
 1334         -
            >,
 1335         -
        >,
 1336         -
        pub(crate) complex_map: ::std::option::Option<
 1337         -
            crate::constrained::MaybeConstrained<
 1338         -
                crate::constrained::complex_map_constrained::ComplexMapConstrained,
 1339         -
            >,
 1340         -
        >,
 1341         -
        pub(crate) complex_union: ::std::option::Option<
 1342         -
            ::std::boxed::Box<crate::constrained::MaybeConstrained<crate::model::ComplexUnion>>,
 1343         -
        >,
        1238  +
        pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
        1239  +
        pub(crate) boolean: ::std::option::Option<bool>,
        1240  +
        pub(crate) string: ::std::option::Option<::std::string::String>,
        1241  +
        pub(crate) byte: ::std::option::Option<i8>,
        1242  +
        pub(crate) short: ::std::option::Option<i16>,
        1243  +
        pub(crate) integer: ::std::option::Option<i32>,
        1244  +
        pub(crate) long: ::std::option::Option<i64>,
        1245  +
        pub(crate) float: ::std::option::Option<f32>,
        1246  +
        pub(crate) double: ::std::option::Option<f64>,
        1247  +
        pub(crate) timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
        1248  +
        pub(crate) r#enum:
        1249  +
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        1250  +
        pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
        1251  +
        pub(crate) required_boolean: ::std::option::Option<bool>,
        1252  +
        pub(crate) required_string: ::std::option::Option<::std::string::String>,
        1253  +
        pub(crate) required_byte: ::std::option::Option<i8>,
        1254  +
        pub(crate) required_short: ::std::option::Option<i16>,
        1255  +
        pub(crate) required_integer: ::std::option::Option<i32>,
        1256  +
        pub(crate) required_long: ::std::option::Option<i64>,
        1257  +
        pub(crate) required_float: ::std::option::Option<f32>,
        1258  +
        pub(crate) required_double: ::std::option::Option<f64>,
        1259  +
        pub(crate) required_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
        1260  +
        pub(crate) required_enum:
        1261  +
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 1344   1262   
    }
 1345   1263   
    impl Builder {
 1346   1264   
        #[allow(missing_docs)] // documentation missing in model
 1347         -
        pub fn structure(
        1265  +
        pub fn blob(mut self, input: ::std::option::Option<::aws_smithy_types::Blob>) -> Self {
        1266  +
            self.blob = input;
        1267  +
            self
        1268  +
        }
        1269  +
        #[allow(missing_docs)] // documentation missing in model
        1270  +
        pub(crate) fn set_blob(
        1271  +
            mut self,
        1272  +
            input: Option<impl ::std::convert::Into<::aws_smithy_types::Blob>>,
        1273  +
        ) -> Self {
        1274  +
            self.blob = input.map(|v| v.into());
        1275  +
            self
        1276  +
        }
        1277  +
        #[allow(missing_docs)] // documentation missing in model
        1278  +
        pub fn boolean(mut self, input: ::std::option::Option<bool>) -> Self {
        1279  +
            self.boolean = input;
        1280  +
            self
        1281  +
        }
        1282  +
        #[allow(missing_docs)] // documentation missing in model
        1283  +
        pub(crate) fn set_boolean(
        1284  +
            mut self,
        1285  +
            input: Option<impl ::std::convert::Into<bool>>,
        1286  +
        ) -> Self {
        1287  +
            self.boolean = input.map(|v| v.into());
        1288  +
            self
        1289  +
        }
        1290  +
        #[allow(missing_docs)] // documentation missing in model
        1291  +
        pub fn string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1292  +
            self.string = input;
        1293  +
            self
        1294  +
        }
        1295  +
        #[allow(missing_docs)] // documentation missing in model
        1296  +
        pub(crate) fn set_string(
        1297  +
            mut self,
        1298  +
            input: Option<impl ::std::convert::Into<::std::string::String>>,
        1299  +
        ) -> Self {
        1300  +
            self.string = input.map(|v| v.into());
        1301  +
            self
        1302  +
        }
        1303  +
        #[allow(missing_docs)] // documentation missing in model
        1304  +
        pub fn byte(mut self, input: ::std::option::Option<i8>) -> Self {
        1305  +
            self.byte = input;
        1306  +
            self
        1307  +
        }
        1308  +
        #[allow(missing_docs)] // documentation missing in model
        1309  +
        pub(crate) fn set_byte(mut self, input: Option<impl ::std::convert::Into<i8>>) -> Self {
        1310  +
            self.byte = input.map(|v| v.into());
        1311  +
            self
        1312  +
        }
        1313  +
        #[allow(missing_docs)] // documentation missing in model
        1314  +
        pub fn short(mut self, input: ::std::option::Option<i16>) -> Self {
        1315  +
            self.short = input;
        1316  +
            self
        1317  +
        }
        1318  +
        #[allow(missing_docs)] // documentation missing in model
        1319  +
        pub(crate) fn set_short(mut self, input: Option<impl ::std::convert::Into<i16>>) -> Self {
        1320  +
            self.short = input.map(|v| v.into());
        1321  +
            self
        1322  +
        }
        1323  +
        #[allow(missing_docs)] // documentation missing in model
        1324  +
        pub fn integer(mut self, input: ::std::option::Option<i32>) -> Self {
        1325  +
            self.integer = input;
        1326  +
            self
        1327  +
        }
        1328  +
        #[allow(missing_docs)] // documentation missing in model
        1329  +
        pub(crate) fn set_integer(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
        1330  +
            self.integer = input.map(|v| v.into());
        1331  +
            self
        1332  +
        }
        1333  +
        #[allow(missing_docs)] // documentation missing in model
        1334  +
        pub fn long(mut self, input: ::std::option::Option<i64>) -> Self {
        1335  +
            self.long = input;
        1336  +
            self
        1337  +
        }
        1338  +
        #[allow(missing_docs)] // documentation missing in model
        1339  +
        pub(crate) fn set_long(mut self, input: Option<impl ::std::convert::Into<i64>>) -> Self {
        1340  +
            self.long = input.map(|v| v.into());
        1341  +
            self
        1342  +
        }
        1343  +
        #[allow(missing_docs)] // documentation missing in model
        1344  +
        pub fn float(mut self, input: ::std::option::Option<f32>) -> Self {
        1345  +
            self.float = input;
        1346  +
            self
        1347  +
        }
        1348  +
        #[allow(missing_docs)] // documentation missing in model
        1349  +
        pub(crate) fn set_float(mut self, input: Option<impl ::std::convert::Into<f32>>) -> Self {
        1350  +
            self.float = input.map(|v| v.into());
        1351  +
            self
        1352  +
        }
        1353  +
        #[allow(missing_docs)] // documentation missing in model
        1354  +
        pub fn double(mut self, input: ::std::option::Option<f64>) -> Self {
        1355  +
            self.double = input;
        1356  +
            self
        1357  +
        }
        1358  +
        #[allow(missing_docs)] // documentation missing in model
        1359  +
        pub(crate) fn set_double(mut self, input: Option<impl ::std::convert::Into<f64>>) -> Self {
        1360  +
            self.double = input.map(|v| v.into());
        1361  +
            self
        1362  +
        }
        1363  +
        #[allow(missing_docs)] // documentation missing in model
        1364  +
        pub fn timestamp(
 1348   1365   
            mut self,
 1349         -
            input: ::std::option::Option<crate::model::SimpleStruct>,
        1366  +
            input: ::std::option::Option<::aws_smithy_types::DateTime>,
 1350   1367   
        ) -> Self {
 1351         -
            self.structure = input.map(crate::constrained::MaybeConstrained::Constrained);
        1368  +
            self.timestamp = input;
 1352   1369   
            self
 1353   1370   
        }
 1354   1371   
        #[allow(missing_docs)] // documentation missing in model
 1355         -
        pub(crate) fn set_structure(
        1372  +
        pub(crate) fn set_timestamp(
 1356   1373   
            mut self,
 1357         -
            input: Option<
 1358         -
                impl ::std::convert::Into<
 1359         -
                    crate::constrained::MaybeConstrained<crate::model::SimpleStruct>,
 1360         -
                >,
 1361         -
            >,
        1374  +
            input: Option<impl ::std::convert::Into<::aws_smithy_types::DateTime>>,
 1362   1375   
        ) -> Self {
 1363         -
            self.structure = input.map(|v| v.into());
        1376  +
            self.timestamp = input.map(|v| v.into());
 1364   1377   
            self
 1365   1378   
        }
 1366   1379   
        #[allow(missing_docs)] // documentation missing in model
 1367         -
        pub fn empty_structure(
 1368         -
            mut self,
 1369         -
            input: ::std::option::Option<crate::model::EmptyStruct>,
 1370         -
        ) -> Self {
 1371         -
            self.empty_structure = input;
        1380  +
        pub fn r#enum(mut self, input: ::std::option::Option<crate::model::Suit>) -> Self {
        1381  +
            self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
 1372   1382   
            self
 1373   1383   
        }
 1374   1384   
        #[allow(missing_docs)] // documentation missing in model
 1375         -
        pub(crate) fn set_empty_structure(
        1385  +
        pub(crate) fn set_enum(
 1376   1386   
            mut self,
 1377         -
            input: Option<impl ::std::convert::Into<crate::model::EmptyStruct>>,
        1387  +
            input: Option<
        1388  +
                impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        1389  +
            >,
 1378   1390   
        ) -> Self {
 1379         -
            self.empty_structure = input.map(|v| v.into());
        1391  +
            self.r#enum = input.map(|v| v.into());
 1380   1392   
            self
 1381   1393   
        }
 1382   1394   
        #[allow(missing_docs)] // documentation missing in model
 1383         -
        pub fn list(
 1384         -
            mut self,
 1385         -
            input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
 1386         -
        ) -> Self {
 1387         -
            self.list = input;
        1395  +
        pub fn required_blob(mut self, input: ::aws_smithy_types::Blob) -> Self {
        1396  +
            self.required_blob = Some(input);
 1388   1397   
            self
 1389   1398   
        }
 1390   1399   
        #[allow(missing_docs)] // documentation missing in model
 1391         -
        pub(crate) fn set_list(
        1400  +
        pub(crate) fn set_required_blob(
 1392   1401   
            mut self,
 1393         -
            input: Option<impl ::std::convert::Into<::std::vec::Vec<::std::string::String>>>,
        1402  +
            input: impl ::std::convert::Into<::aws_smithy_types::Blob>,
 1394   1403   
        ) -> Self {
 1395         -
            self.list = input.map(|v| v.into());
        1404  +
            self.required_blob = Some(input.into());
 1396   1405   
            self
 1397   1406   
        }
 1398   1407   
        #[allow(missing_docs)] // documentation missing in model
 1399         -
        pub fn map(
 1400         -
            mut self,
 1401         -
            input: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
 1402         -
        ) -> Self {
 1403         -
            self.map = input;
        1408  +
        pub fn required_boolean(mut self, input: bool) -> Self {
        1409  +
            self.required_boolean = Some(input);
 1404   1410   
            self
 1405   1411   
        }
 1406   1412   
        #[allow(missing_docs)] // documentation missing in model
 1407         -
        pub(crate) fn set_map(
        1413  +
        pub(crate) fn set_required_boolean(
 1408   1414   
            mut self,
 1409         -
            input: Option<
 1410         -
                impl ::std::convert::Into<::std::collections::HashMap<::std::string::String, i32>>,
 1411         -
            >,
        1415  +
            input: impl ::std::convert::Into<bool>,
 1412   1416   
        ) -> Self {
 1413         -
            self.map = input.map(|v| v.into());
        1417  +
            self.required_boolean = Some(input.into());
 1414   1418   
            self
 1415   1419   
        }
 1416   1420   
        #[allow(missing_docs)] // documentation missing in model
 1417         -
        pub fn union(mut self, input: ::std::option::Option<crate::model::SimpleUnion>) -> Self {
 1418         -
            self.union = input;
        1421  +
        pub fn required_string(mut self, input: ::std::string::String) -> Self {
        1422  +
            self.required_string = Some(input);
 1419   1423   
            self
 1420   1424   
        }
 1421   1425   
        #[allow(missing_docs)] // documentation missing in model
 1422         -
        pub(crate) fn set_union(
        1426  +
        pub(crate) fn set_required_string(
 1423   1427   
            mut self,
 1424         -
            input: Option<impl ::std::convert::Into<crate::model::SimpleUnion>>,
        1428  +
            input: impl ::std::convert::Into<::std::string::String>,
 1425   1429   
        ) -> Self {
 1426         -
            self.union = input.map(|v| v.into());
        1430  +
            self.required_string = Some(input.into());
 1427   1431   
            self
 1428   1432   
        }
 1429   1433   
        #[allow(missing_docs)] // documentation missing in model
 1430         -
        pub fn unit_union(mut self, input: ::std::option::Option<crate::model::UnitUnion>) -> Self {
 1431         -
            self.unit_union = input;
        1434  +
        pub fn required_byte(mut self, input: i8) -> Self {
        1435  +
            self.required_byte = Some(input);
 1432   1436   
            self
 1433   1437   
        }
 1434   1438   
        #[allow(missing_docs)] // documentation missing in model
 1435         -
        pub(crate) fn set_unit_union(
 1436         -
            mut self,
 1437         -
            input: Option<impl ::std::convert::Into<crate::model::UnitUnion>>,
 1438         -
        ) -> Self {
 1439         -
            self.unit_union = input.map(|v| v.into());
        1439  +
        pub(crate) fn set_required_byte(mut self, input: impl ::std::convert::Into<i8>) -> Self {
        1440  +
            self.required_byte = Some(input.into());
 1440   1441   
            self
 1441   1442   
        }
 1442   1443   
        #[allow(missing_docs)] // documentation missing in model
 1443         -
        pub fn structure_list(
 1444         -
            mut self,
 1445         -
            input: ::std::option::Option<::std::vec::Vec<crate::model::SimpleStruct>>,
 1446         -
        ) -> Self {
 1447         -
            self.structure_list =
 1448         -
                input.map(|v| crate::constrained::MaybeConstrained::Constrained((v).into()));
        1444  +
        pub fn required_short(mut self, input: i16) -> Self {
        1445  +
            self.required_short = Some(input);
 1449   1446   
            self
 1450   1447   
        }
 1451   1448   
        #[allow(missing_docs)] // documentation missing in model
 1452         -
        pub(crate) fn set_structure_list(
 1453         -
            mut self,
 1454         -
            input: Option<
 1455         -
                impl ::std::convert::Into<
 1456         -
                    crate::constrained::MaybeConstrained<
 1457         -
                        crate::constrained::struct_list_constrained::StructListConstrained,
 1458         -
                    >,
 1459         -
                >,
 1460         -
            >,
 1461         -
        ) -> Self {
 1462         -
            self.structure_list = input.map(|v| v.into());
        1449  +
        pub(crate) fn set_required_short(mut self, input: impl ::std::convert::Into<i16>) -> Self {
        1450  +
            self.required_short = Some(input.into());
 1463   1451   
            self
 1464   1452   
        }
 1465   1453   
        #[allow(missing_docs)] // documentation missing in model
 1466         -
        pub fn complex_list(
 1467         -
            mut self,
 1468         -
            input: ::std::vec::Vec<
 1469         -
                ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
 1470         -
            >,
 1471         -
        ) -> Self {
 1472         -
            self.complex_list = Some(crate::constrained::MaybeConstrained::Constrained(
 1473         -
                (input).into(),
 1474         -
            ));
        1454  +
        pub fn required_integer(mut self, input: i32) -> Self {
        1455  +
            self.required_integer = Some(input);
 1475   1456   
            self
 1476   1457   
        }
 1477   1458   
        #[allow(missing_docs)] // documentation missing in model
 1478         -
        pub(crate) fn set_complex_list(
        1459  +
        pub(crate) fn set_required_integer(
 1479   1460   
            mut self,
 1480         -
            input: impl ::std::convert::Into<
 1481         -
                crate::constrained::MaybeConstrained<
 1482         -
                    crate::constrained::complex_list_constrained::ComplexListConstrained,
 1483         -
                >,
 1484         -
            >,
        1461  +
            input: impl ::std::convert::Into<i32>,
 1485   1462   
        ) -> Self {
 1486         -
            self.complex_list = Some(input.into());
        1463  +
            self.required_integer = Some(input.into());
 1487   1464   
            self
 1488   1465   
        }
 1489   1466   
        #[allow(missing_docs)] // documentation missing in model
 1490         -
        pub fn complex_map(
 1491         -
            mut self,
 1492         -
            input: ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
 1493         -
        ) -> Self {
 1494         -
            self.complex_map = Some(crate::constrained::MaybeConstrained::Constrained(
 1495         -
                (input).into(),
 1496         -
            ));
        1467  +
        pub fn required_long(mut self, input: i64) -> Self {
        1468  +
            self.required_long = Some(input);
 1497   1469   
            self
 1498   1470   
        }
 1499   1471   
        #[allow(missing_docs)] // documentation missing in model
 1500         -
        pub(crate) fn set_complex_map(
 1501         -
            mut self,
 1502         -
            input: impl ::std::convert::Into<
 1503         -
                crate::constrained::MaybeConstrained<
 1504         -
                    crate::constrained::complex_map_constrained::ComplexMapConstrained,
 1505         -
                >,
 1506         -
            >,
 1507         -
        ) -> Self {
 1508         -
            self.complex_map = Some(input.into());
        1472  +
        pub(crate) fn set_required_long(mut self, input: impl ::std::convert::Into<i64>) -> Self {
        1473  +
            self.required_long = Some(input.into());
 1509   1474   
            self
 1510   1475   
        }
 1511   1476   
        #[allow(missing_docs)] // documentation missing in model
 1512         -
        #[allow(clippy::boxed_local)]
 1513         -
        pub fn complex_union(
        1477  +
        pub fn required_float(mut self, input: f32) -> Self {
        1478  +
            self.required_float = Some(input);
        1479  +
            self
        1480  +
        }
        1481  +
        #[allow(missing_docs)] // documentation missing in model
        1482  +
        pub(crate) fn set_required_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
        1483  +
            self.required_float = Some(input.into());
        1484  +
            self
        1485  +
        }
        1486  +
        #[allow(missing_docs)] // documentation missing in model
        1487  +
        pub fn required_double(mut self, input: f64) -> Self {
        1488  +
            self.required_double = Some(input);
        1489  +
            self
        1490  +
        }
        1491  +
        #[allow(missing_docs)] // documentation missing in model
        1492  +
        pub(crate) fn set_required_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
        1493  +
            self.required_double = Some(input.into());
        1494  +
            self
        1495  +
        }
        1496  +
        #[allow(missing_docs)] // documentation missing in model
        1497  +
        pub fn required_timestamp(mut self, input: ::aws_smithy_types::DateTime) -> Self {
        1498  +
            self.required_timestamp = Some(input);
        1499  +
            self
        1500  +
        }
        1501  +
        #[allow(missing_docs)] // documentation missing in model
        1502  +
        pub(crate) fn set_required_timestamp(
 1514   1503   
            mut self,
 1515         -
            input: ::std::boxed::Box<crate::model::ComplexUnion>,
        1504  +
            input: impl ::std::convert::Into<::aws_smithy_types::DateTime>,
 1516   1505   
        ) -> Self {
 1517         -
            self.complex_union = Some(Box::new(crate::constrained::MaybeConstrained::Constrained(
 1518         -
                *input,
 1519         -
            )));
        1506  +
            self.required_timestamp = Some(input.into());
 1520   1507   
            self
 1521   1508   
        }
 1522   1509   
        #[allow(missing_docs)] // documentation missing in model
 1523         -
        pub(crate) fn set_complex_union(
        1510  +
        pub fn required_enum(mut self, input: crate::model::Suit) -> Self {
        1511  +
            self.required_enum = Some(crate::constrained::MaybeConstrained::Constrained(input));
        1512  +
            self
        1513  +
        }
        1514  +
        #[allow(missing_docs)] // documentation missing in model
        1515  +
        pub(crate) fn set_required_enum(
 1524   1516   
            mut self,
 1525         -
            input: impl ::std::convert::Into<
 1526         -
                ::std::boxed::Box<crate::constrained::MaybeConstrained<crate::model::ComplexUnion>>,
 1527         -
            >,
        1517  +
            input: impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 1528   1518   
        ) -> Self {
 1529         -
            self.complex_union = Some(input.into());
        1519  +
            self.required_enum = Some(input.into());
 1530   1520   
            self
 1531   1521   
        }
 1532         -
        /// Consumes the builder and constructs a [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
        1522  +
        /// Consumes the builder and constructs a [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
 1533   1523   
        ///
 1534         -
        /// The builder fails to construct a [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput) if a [`ConstraintViolation`] occurs.
        1524  +
        /// The builder fails to construct a [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput) if a [`ConstraintViolation`] occurs.
 1535   1525   
        ///
 1536   1526   
        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
 1537   1527   
        pub fn build(
 1538   1528   
            self,
 1539         -
        ) -> Result<crate::input::ComplexStructOperationInput, ConstraintViolation> {
        1529  +
        ) -> Result<crate::input::ErrorSerializationOperationInput, ConstraintViolation> {
 1540   1530   
            self.build_enforcing_all_constraints()
 1541   1531   
        }
 1542   1532   
        fn build_enforcing_all_constraints(
 1543   1533   
            self,
 1544         -
        ) -> Result<crate::input::ComplexStructOperationInput, ConstraintViolation> {
 1545         -
            Ok(crate::input::ComplexStructOperationInput {
 1546         -
                structure: self
 1547         -
                    .structure
 1548         -
                    .map(|v| match v {
 1549         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 1550         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 1551         -
                    })
 1552         -
                    .map(|res| res.map_err(ConstraintViolation::Structure))
 1553         -
                    .transpose()?,
 1554         -
                empty_structure: self.empty_structure,
 1555         -
                list: self.list,
 1556         -
                map: self.map,
 1557         -
                union: self.union,
 1558         -
                unit_union: self.unit_union,
 1559         -
                structure_list: self
 1560         -
                    .structure_list
        1534  +
        ) -> Result<crate::input::ErrorSerializationOperationInput, ConstraintViolation> {
        1535  +
            Ok(crate::input::ErrorSerializationOperationInput {
        1536  +
                blob: self.blob,
        1537  +
                boolean: self.boolean,
        1538  +
                string: self.string,
        1539  +
                byte: self.byte,
        1540  +
                short: self.short,
        1541  +
                integer: self.integer,
        1542  +
                long: self.long,
        1543  +
                float: self.float,
        1544  +
                double: self.double,
        1545  +
                timestamp: self.timestamp,
        1546  +
                r#enum: self
        1547  +
                    .r#enum
 1561   1548   
                    .map(|v| match v {
 1562   1549   
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 1563   1550   
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 1564   1551   
                    })
 1565         -
                    .map(|res| {
 1566         -
                        res.map(|v| v.into())
 1567         -
                            .map_err(ConstraintViolation::StructureList)
 1568         -
                    })
        1552  +
                    .map(|res| res.map_err(ConstraintViolation::Enum))
 1569   1553   
                    .transpose()?,
 1570         -
                complex_list: self
 1571         -
                    .complex_list
 1572         -
                    .map(|v| match v {
 1573         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 1574         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 1575         -
                    })
 1576         -
                    .map(|res| {
 1577         -
                        res.map(|v| v.into())
 1578         -
                            .map_err(ConstraintViolation::ComplexList)
 1579         -
                    })
 1580         -
                    .transpose()?
 1581         -
                    .ok_or(ConstraintViolation::MissingComplexList)?,
 1582         -
                complex_map: self
 1583         -
                    .complex_map
        1554  +
                required_blob: self
        1555  +
                    .required_blob
        1556  +
                    .ok_or(ConstraintViolation::MissingRequiredBlob)?,
        1557  +
                required_boolean: self
        1558  +
                    .required_boolean
        1559  +
                    .ok_or(ConstraintViolation::MissingRequiredBoolean)?,
        1560  +
                required_string: self
        1561  +
                    .required_string
        1562  +
                    .ok_or(ConstraintViolation::MissingRequiredString)?,
        1563  +
                required_byte: self
        1564  +
                    .required_byte
        1565  +
                    .ok_or(ConstraintViolation::MissingRequiredByte)?,
        1566  +
                required_short: self
        1567  +
                    .required_short
        1568  +
                    .ok_or(ConstraintViolation::MissingRequiredShort)?,
        1569  +
                required_integer: self
        1570  +
                    .required_integer
        1571  +
                    .ok_or(ConstraintViolation::MissingRequiredInteger)?,
        1572  +
                required_long: self
        1573  +
                    .required_long
        1574  +
                    .ok_or(ConstraintViolation::MissingRequiredLong)?,
        1575  +
                required_float: self
        1576  +
                    .required_float
        1577  +
                    .ok_or(ConstraintViolation::MissingRequiredFloat)?,
        1578  +
                required_double: self
        1579  +
                    .required_double
        1580  +
                    .ok_or(ConstraintViolation::MissingRequiredDouble)?,
        1581  +
                required_timestamp: self
        1582  +
                    .required_timestamp
        1583  +
                    .ok_or(ConstraintViolation::MissingRequiredTimestamp)?,
        1584  +
                required_enum: self
        1585  +
                    .required_enum
 1584   1586   
                    .map(|v| match v {
 1585   1587   
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 1586   1588   
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 1587   1589   
                    })
 1588         -
                    .map(|res| {
 1589         -
                        res.map(|v| v.into())
 1590         -
                            .map_err(ConstraintViolation::ComplexMap)
 1591         -
                    })
 1592         -
                    .transpose()?
 1593         -
                    .ok_or(ConstraintViolation::MissingComplexMap)?,
 1594         -
                complex_union: self
 1595         -
                    .complex_union
 1596         -
                    .map(|v| match *v {
 1597         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(Box::new(x)),
 1598         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => {
 1599         -
                            Ok(Box::new(x.try_into()?))
 1600         -
                        }
 1601         -
                    })
 1602         -
                    .map(|res| {
 1603         -
                        res.map_err(Box::new)
 1604         -
                            .map_err(ConstraintViolation::ComplexUnion)
 1605         -
                    })
        1590  +
                    .map(|res| res.map_err(ConstraintViolation::RequiredEnum))
 1606   1591   
                    .transpose()?
 1607         -
                    .ok_or(ConstraintViolation::MissingComplexUnion)?,
        1592  +
                    .ok_or(ConstraintViolation::MissingRequiredEnum)?,
 1608   1593   
            })
 1609   1594   
        }
 1610   1595   
    }
 1611   1596   
}
 1612         -
/// See [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
 1613         -
pub mod error_serialization_operation_input {
        1597  +
/// See [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
        1598  +
pub mod complex_struct_operation_input {
 1614   1599   
 1615   1600   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
 1616   1601   
    /// Holds one variant for each of the ways the builder can fail.
 1617   1602   
    #[non_exhaustive]
 1618   1603   
    #[allow(clippy::enum_variant_names)]
 1619   1604   
    pub enum ConstraintViolation {
 1620         -
        /// Constraint violation occurred building member `r#enum` when building `ErrorSerializationOperationInput`.
        1605  +
        /// Constraint violation occurred building member `structure` when building `ComplexStructOperationInput`.
 1621   1606   
        #[doc(hidden)]
 1622         -
        Enum(crate::model::suit::ConstraintViolation),
 1623         -
        /// `required_blob` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1624         -
        MissingRequiredBlob,
 1625         -
        /// `required_boolean` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1626         -
        MissingRequiredBoolean,
 1627         -
        /// `required_string` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1628         -
        MissingRequiredString,
 1629         -
        /// `required_byte` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1630         -
        MissingRequiredByte,
 1631         -
        /// `required_short` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1632         -
        MissingRequiredShort,
 1633         -
        /// `required_integer` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1634         -
        MissingRequiredInteger,
 1635         -
        /// `required_long` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1636         -
        MissingRequiredLong,
 1637         -
        /// `required_float` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1638         -
        MissingRequiredFloat,
 1639         -
        /// `required_double` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1640         -
        MissingRequiredDouble,
 1641         -
        /// `required_timestamp` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1642         -
        MissingRequiredTimestamp,
 1643         -
        /// `required_enum` was not provided but it is required when building `ErrorSerializationOperationInput`.
 1644         -
        MissingRequiredEnum,
 1645         -
        /// Constraint violation occurred building member `required_enum` when building `ErrorSerializationOperationInput`.
        1607  +
        Structure(crate::model::simple_struct::ConstraintViolation),
        1608  +
        /// Constraint violation occurred building member `structure_list` when building `ComplexStructOperationInput`.
 1646   1609   
        #[doc(hidden)]
 1647         -
        RequiredEnum(crate::model::suit::ConstraintViolation),
        1610  +
        StructureList(crate::model::struct_list::ConstraintViolation),
        1611  +
        /// `complex_list` was not provided but it is required when building `ComplexStructOperationInput`.
        1612  +
        MissingComplexList,
        1613  +
        /// Constraint violation occurred building member `complex_list` when building `ComplexStructOperationInput`.
        1614  +
        #[doc(hidden)]
        1615  +
        ComplexList(crate::model::complex_list::ConstraintViolation),
        1616  +
        /// `complex_map` was not provided but it is required when building `ComplexStructOperationInput`.
        1617  +
        MissingComplexMap,
        1618  +
        /// Constraint violation occurred building member `complex_map` when building `ComplexStructOperationInput`.
        1619  +
        #[doc(hidden)]
        1620  +
        ComplexMap(crate::model::complex_map::ConstraintViolation),
        1621  +
        /// `complex_union` was not provided but it is required when building `ComplexStructOperationInput`.
        1622  +
        MissingComplexUnion,
        1623  +
        /// Constraint violation occurred building member `complex_union` when building `ComplexStructOperationInput`.
        1624  +
        #[doc(hidden)]
        1625  +
        ComplexUnion(::std::boxed::Box<crate::model::complex_union::ConstraintViolation>),
 1648   1626   
    }
 1649   1627   
    impl ::std::fmt::Display for ConstraintViolation {
 1650   1628   
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1651   1629   
            match self {
 1652         -
                ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `ErrorSerializationOperationInput`"),
 1653         -
                ConstraintViolation::MissingRequiredBlob => write!(f, "`required_blob` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1654         -
                ConstraintViolation::MissingRequiredBoolean => write!(f, "`required_boolean` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1655         -
                ConstraintViolation::MissingRequiredString => write!(f, "`required_string` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1656         -
                ConstraintViolation::MissingRequiredByte => write!(f, "`required_byte` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1657         -
                ConstraintViolation::MissingRequiredShort => write!(f, "`required_short` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1658         -
                ConstraintViolation::MissingRequiredInteger => write!(f, "`required_integer` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1659         -
                ConstraintViolation::MissingRequiredLong => write!(f, "`required_long` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1660         -
                ConstraintViolation::MissingRequiredFloat => write!(f, "`required_float` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1661         -
                ConstraintViolation::MissingRequiredDouble => write!(f, "`required_double` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1662         -
                ConstraintViolation::MissingRequiredTimestamp => write!(f, "`required_timestamp` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1663         -
                ConstraintViolation::MissingRequiredEnum => write!(f, "`required_enum` was not provided but it is required when building `ErrorSerializationOperationInput`"),
 1664         -
                ConstraintViolation::RequiredEnum(_) => write!(f, "constraint violation occurred building member `required_enum` when building `ErrorSerializationOperationInput`"),
        1630  +
                ConstraintViolation::Structure(_) => write!(f, "constraint violation occurred building member `structure` when building `ComplexStructOperationInput`"),
        1631  +
                ConstraintViolation::StructureList(_) => write!(f, "constraint violation occurred building member `structure_list` when building `ComplexStructOperationInput`"),
        1632  +
                ConstraintViolation::MissingComplexList => write!(f, "`complex_list` was not provided but it is required when building `ComplexStructOperationInput`"),
        1633  +
                ConstraintViolation::ComplexList(_) => write!(f, "constraint violation occurred building member `complex_list` when building `ComplexStructOperationInput`"),
        1634  +
                ConstraintViolation::MissingComplexMap => write!(f, "`complex_map` was not provided but it is required when building `ComplexStructOperationInput`"),
        1635  +
                ConstraintViolation::ComplexMap(_) => write!(f, "constraint violation occurred building member `complex_map` when building `ComplexStructOperationInput`"),
        1636  +
                ConstraintViolation::MissingComplexUnion => write!(f, "`complex_union` was not provided but it is required when building `ComplexStructOperationInput`"),
        1637  +
                ConstraintViolation::ComplexUnion(_) => write!(f, "constraint violation occurred building member `complex_union` when building `ComplexStructOperationInput`"),
 1665   1638   
            }
 1666   1639   
        }
 1667   1640   
    }
 1668   1641   
    impl ::std::error::Error for ConstraintViolation {}
 1669   1642   
    impl ConstraintViolation {
 1670   1643   
        pub(crate) fn as_validation_exception_field(
 1671   1644   
            self,
 1672   1645   
            path: ::std::string::String,
 1673   1646   
        ) -> crate::model::ValidationExceptionField {
 1674   1647   
            match self {
 1675         -
            ConstraintViolation::Enum(inner) => inner.as_validation_exception_field(path + "/enum"),
 1676         -
            ConstraintViolation::MissingRequiredBlob => crate::model::ValidationExceptionField {
 1677         -
                                                message: format!("Value at '{}/requiredBlob' failed to satisfy constraint: Member must not be null", path),
 1678         -
                                                path: path + "/requiredBlob",
 1679         -
                                            },
 1680         -
            ConstraintViolation::MissingRequiredBoolean => crate::model::ValidationExceptionField {
 1681         -
                                                message: format!("Value at '{}/requiredBoolean' failed to satisfy constraint: Member must not be null", path),
 1682         -
                                                path: path + "/requiredBoolean",
 1683         -
                                            },
 1684         -
            ConstraintViolation::MissingRequiredString => crate::model::ValidationExceptionField {
 1685         -
                                                message: format!("Value at '{}/requiredString' failed to satisfy constraint: Member must not be null", path),
 1686         -
                                                path: path + "/requiredString",
 1687         -
                                            },
 1688         -
            ConstraintViolation::MissingRequiredByte => crate::model::ValidationExceptionField {
 1689         -
                                                message: format!("Value at '{}/requiredByte' failed to satisfy constraint: Member must not be null", path),
 1690         -
                                                path: path + "/requiredByte",
 1691         -
                                            },
 1692         -
            ConstraintViolation::MissingRequiredShort => crate::model::ValidationExceptionField {
 1693         -
                                                message: format!("Value at '{}/requiredShort' failed to satisfy constraint: Member must not be null", path),
 1694         -
                                                path: path + "/requiredShort",
 1695         -
                                            },
 1696         -
            ConstraintViolation::MissingRequiredInteger => crate::model::ValidationExceptionField {
 1697         -
                                                message: format!("Value at '{}/requiredInteger' failed to satisfy constraint: Member must not be null", path),
 1698         -
                                                path: path + "/requiredInteger",
 1699         -
                                            },
 1700         -
            ConstraintViolation::MissingRequiredLong => crate::model::ValidationExceptionField {
 1701         -
                                                message: format!("Value at '{}/requiredLong' failed to satisfy constraint: Member must not be null", path),
 1702         -
                                                path: path + "/requiredLong",
 1703         -
                                            },
 1704         -
            ConstraintViolation::MissingRequiredFloat => crate::model::ValidationExceptionField {
 1705         -
                                                message: format!("Value at '{}/requiredFloat' failed to satisfy constraint: Member must not be null", path),
 1706         -
                                                path: path + "/requiredFloat",
 1707         -
                                            },
 1708         -
            ConstraintViolation::MissingRequiredDouble => crate::model::ValidationExceptionField {
 1709         -
                                                message: format!("Value at '{}/requiredDouble' failed to satisfy constraint: Member must not be null", path),
 1710         -
                                                path: path + "/requiredDouble",
        1648  +
            ConstraintViolation::Structure(inner) => inner.as_validation_exception_field(path + "/structure"),
        1649  +
            ConstraintViolation::StructureList(inner) => inner.as_validation_exception_field(path + "/structureList"),
        1650  +
            ConstraintViolation::MissingComplexList => crate::model::ValidationExceptionField {
        1651  +
                                                message: format!("Value at '{}/complexList' failed to satisfy constraint: Member must not be null", path),
        1652  +
                                                path: path + "/complexList",
 1711   1653   
                                            },
 1712         -
            ConstraintViolation::MissingRequiredTimestamp => crate::model::ValidationExceptionField {
 1713         -
                                                message: format!("Value at '{}/requiredTimestamp' failed to satisfy constraint: Member must not be null", path),
 1714         -
                                                path: path + "/requiredTimestamp",
        1654  +
            ConstraintViolation::ComplexList(inner) => inner.as_validation_exception_field(path + "/complexList"),
        1655  +
            ConstraintViolation::MissingComplexMap => crate::model::ValidationExceptionField {
        1656  +
                                                message: format!("Value at '{}/complexMap' failed to satisfy constraint: Member must not be null", path),
        1657  +
                                                path: path + "/complexMap",
 1715   1658   
                                            },
 1716         -
            ConstraintViolation::MissingRequiredEnum => crate::model::ValidationExceptionField {
 1717         -
                                                message: format!("Value at '{}/requiredEnum' failed to satisfy constraint: Member must not be null", path),
 1718         -
                                                path: path + "/requiredEnum",
        1659  +
            ConstraintViolation::ComplexMap(inner) => inner.as_validation_exception_field(path + "/complexMap"),
        1660  +
            ConstraintViolation::MissingComplexUnion => crate::model::ValidationExceptionField {
        1661  +
                                                message: format!("Value at '{}/complexUnion' failed to satisfy constraint: Member must not be null", path),
        1662  +
                                                path: path + "/complexUnion",
 1719   1663   
                                            },
 1720         -
            ConstraintViolation::RequiredEnum(inner) => inner.as_validation_exception_field(path + "/requiredEnum"),
        1664  +
            ConstraintViolation::ComplexUnion(inner) => inner.as_validation_exception_field(path + "/complexUnion"),
 1721   1665   
        }
 1722   1666   
        }
 1723   1667   
    }
 1724   1668   
    impl ::std::convert::From<ConstraintViolation>
 1725   1669   
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
 1726   1670   
    {
 1727   1671   
        fn from(constraint_violation: ConstraintViolation) -> Self {
 1728   1672   
            let first_validation_exception_field =
 1729   1673   
                constraint_violation.as_validation_exception_field("".to_owned());
 1730   1674   
            let validation_exception = crate::error::ValidationException {
 1731   1675   
                message: format!(
 1732   1676   
                    "1 validation error detected. {}",
 1733   1677   
                    &first_validation_exception_field.message
 1734   1678   
                ),
 1735   1679   
                field_list: Some(vec![first_validation_exception_field]),
 1736   1680   
            };
 1737   1681   
            Self::ConstraintViolation(
 1738   1682   
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
 1739   1683   
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
 1740   1684   
                            )
 1741   1685   
        }
 1742   1686   
    }
 1743   1687   
    impl ::std::convert::From<Builder>
 1744         -
        for crate::constrained::MaybeConstrained<crate::input::ErrorSerializationOperationInput>
        1688  +
        for crate::constrained::MaybeConstrained<crate::input::ComplexStructOperationInput>
 1745   1689   
    {
 1746   1690   
        fn from(builder: Builder) -> Self {
 1747   1691   
            Self::Unconstrained(builder)
 1748   1692   
        }
 1749   1693   
    }
 1750         -
    impl ::std::convert::TryFrom<Builder> for crate::input::ErrorSerializationOperationInput {
        1694  +
    impl ::std::convert::TryFrom<Builder> for crate::input::ComplexStructOperationInput {
 1751   1695   
        type Error = ConstraintViolation;
 1752   1696   
 1753   1697   
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
 1754   1698   
            builder.build()
 1755   1699   
        }
 1756   1700   
    }
 1757         -
    /// A builder for [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
        1701  +
    /// A builder for [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
 1758   1702   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 1759   1703   
    pub struct Builder {
 1760         -
        pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
 1761         -
        pub(crate) boolean: ::std::option::Option<bool>,
 1762         -
        pub(crate) string: ::std::option::Option<::std::string::String>,
 1763         -
        pub(crate) byte: ::std::option::Option<i8>,
 1764         -
        pub(crate) short: ::std::option::Option<i16>,
 1765         -
        pub(crate) integer: ::std::option::Option<i32>,
 1766         -
        pub(crate) long: ::std::option::Option<i64>,
 1767         -
        pub(crate) float: ::std::option::Option<f32>,
 1768         -
        pub(crate) double: ::std::option::Option<f64>,
 1769         -
        pub(crate) timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
 1770         -
        pub(crate) r#enum:
 1771         -
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 1772         -
        pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
 1773         -
        pub(crate) required_boolean: ::std::option::Option<bool>,
 1774         -
        pub(crate) required_string: ::std::option::Option<::std::string::String>,
 1775         -
        pub(crate) required_byte: ::std::option::Option<i8>,
 1776         -
        pub(crate) required_short: ::std::option::Option<i16>,
 1777         -
        pub(crate) required_integer: ::std::option::Option<i32>,
 1778         -
        pub(crate) required_long: ::std::option::Option<i64>,
 1779         -
        pub(crate) required_float: ::std::option::Option<f32>,
 1780         -
        pub(crate) required_double: ::std::option::Option<f64>,
 1781         -
        pub(crate) required_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
 1782         -
        pub(crate) required_enum:
 1783         -
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        1704  +
        pub(crate) structure:
        1705  +
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SimpleStruct>>,
        1706  +
        pub(crate) empty_structure: ::std::option::Option<crate::model::EmptyStruct>,
        1707  +
        pub(crate) list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
        1708  +
        pub(crate) map:
        1709  +
            ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
        1710  +
        pub(crate) union: ::std::option::Option<crate::model::SimpleUnion>,
        1711  +
        pub(crate) unit_union: ::std::option::Option<crate::model::UnitUnion>,
        1712  +
        pub(crate) structure_list: ::std::option::Option<
        1713  +
            crate::constrained::MaybeConstrained<
        1714  +
                crate::constrained::struct_list_constrained::StructListConstrained,
        1715  +
            >,
        1716  +
        >,
        1717  +
        pub(crate) complex_list: ::std::option::Option<
        1718  +
            crate::constrained::MaybeConstrained<
        1719  +
                crate::constrained::complex_list_constrained::ComplexListConstrained,
        1720  +
            >,
        1721  +
        >,
        1722  +
        pub(crate) complex_map: ::std::option::Option<
        1723  +
            crate::constrained::MaybeConstrained<
        1724  +
                crate::constrained::complex_map_constrained::ComplexMapConstrained,
        1725  +
            >,
        1726  +
        >,
        1727  +
        pub(crate) complex_union: ::std::option::Option<
        1728  +
            ::std::boxed::Box<crate::constrained::MaybeConstrained<crate::model::ComplexUnion>>,
        1729  +
        >,
 1784   1730   
    }
 1785   1731   
    impl Builder {
 1786   1732   
        #[allow(missing_docs)] // documentation missing in model
 1787         -
        pub fn blob(mut self, input: ::std::option::Option<::aws_smithy_types::Blob>) -> Self {
 1788         -
            self.blob = input;
 1789         -
            self
 1790         -
        }
 1791         -
        #[allow(missing_docs)] // documentation missing in model
 1792         -
        pub(crate) fn set_blob(
        1733  +
        pub fn structure(
 1793   1734   
            mut self,
 1794         -
            input: Option<impl ::std::convert::Into<::aws_smithy_types::Blob>>,
        1735  +
            input: ::std::option::Option<crate::model::SimpleStruct>,
 1795   1736   
        ) -> Self {
 1796         -
            self.blob = input.map(|v| v.into());
 1797         -
            self
 1798         -
        }
 1799         -
        #[allow(missing_docs)] // documentation missing in model
 1800         -
        pub fn boolean(mut self, input: ::std::option::Option<bool>) -> Self {
 1801         -
            self.boolean = input;
        1737  +
            self.structure = input.map(crate::constrained::MaybeConstrained::Constrained);
 1802   1738   
            self
 1803   1739   
        }
 1804   1740   
        #[allow(missing_docs)] // documentation missing in model
 1805         -
        pub(crate) fn set_boolean(
        1741  +
        pub(crate) fn set_structure(
 1806   1742   
            mut self,
 1807         -
            input: Option<impl ::std::convert::Into<bool>>,
        1743  +
            input: Option<
        1744  +
                impl ::std::convert::Into<
        1745  +
                    crate::constrained::MaybeConstrained<crate::model::SimpleStruct>,
        1746  +
                >,
        1747  +
            >,
 1808   1748   
        ) -> Self {
 1809         -
            self.boolean = input.map(|v| v.into());
        1749  +
            self.structure = input.map(|v| v.into());
 1810   1750   
            self
 1811   1751   
        }
 1812   1752   
        #[allow(missing_docs)] // documentation missing in model
 1813         -
        pub fn string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
 1814         -
            self.string = input;
        1753  +
        pub fn empty_structure(
        1754  +
            mut self,
        1755  +
            input: ::std::option::Option<crate::model::EmptyStruct>,
        1756  +
        ) -> Self {
        1757  +
            self.empty_structure = input;
 1815   1758   
            self
 1816   1759   
        }
 1817   1760   
        #[allow(missing_docs)] // documentation missing in model
 1818         -
        pub(crate) fn set_string(
        1761  +
        pub(crate) fn set_empty_structure(
 1819   1762   
            mut self,
 1820         -
            input: Option<impl ::std::convert::Into<::std::string::String>>,
        1763  +
            input: Option<impl ::std::convert::Into<crate::model::EmptyStruct>>,
 1821   1764   
        ) -> Self {
 1822         -
            self.string = input.map(|v| v.into());
        1765  +
            self.empty_structure = input.map(|v| v.into());
 1823   1766   
            self
 1824   1767   
        }
 1825   1768   
        #[allow(missing_docs)] // documentation missing in model
 1826         -
        pub fn byte(mut self, input: ::std::option::Option<i8>) -> Self {
 1827         -
            self.byte = input;
        1769  +
        pub fn list(
        1770  +
            mut self,
        1771  +
            input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
        1772  +
        ) -> Self {
        1773  +
            self.list = input;
 1828   1774   
            self
 1829   1775   
        }
 1830   1776   
        #[allow(missing_docs)] // documentation missing in model
 1831         -
        pub(crate) fn set_byte(mut self, input: Option<impl ::std::convert::Into<i8>>) -> Self {
 1832         -
            self.byte = input.map(|v| v.into());
        1777  +
        pub(crate) fn set_list(
        1778  +
            mut self,
        1779  +
            input: Option<impl ::std::convert::Into<::std::vec::Vec<::std::string::String>>>,
        1780  +
        ) -> Self {
        1781  +
            self.list = input.map(|v| v.into());
 1833   1782   
            self
 1834   1783   
        }
 1835   1784   
        #[allow(missing_docs)] // documentation missing in model
 1836         -
        pub fn short(mut self, input: ::std::option::Option<i16>) -> Self {
 1837         -
            self.short = input;
        1785  +
        pub fn map(
        1786  +
            mut self,
        1787  +
            input: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
        1788  +
        ) -> Self {
        1789  +
            self.map = input;
 1838   1790   
            self
 1839   1791   
        }
 1840   1792   
        #[allow(missing_docs)] // documentation missing in model
 1841         -
        pub(crate) fn set_short(mut self, input: Option<impl ::std::convert::Into<i16>>) -> Self {
 1842         -
            self.short = input.map(|v| v.into());
        1793  +
        pub(crate) fn set_map(
        1794  +
            mut self,
        1795  +
            input: Option<
        1796  +
                impl ::std::convert::Into<::std::collections::HashMap<::std::string::String, i32>>,
        1797  +
            >,
        1798  +
        ) -> Self {
        1799  +
            self.map = input.map(|v| v.into());
 1843   1800   
            self
 1844   1801   
        }
 1845   1802   
        #[allow(missing_docs)] // documentation missing in model
 1846         -
        pub fn integer(mut self, input: ::std::option::Option<i32>) -> Self {
 1847         -
            self.integer = input;
        1803  +
        pub fn union(mut self, input: ::std::option::Option<crate::model::SimpleUnion>) -> Self {
        1804  +
            self.union = input;
 1848   1805   
            self
 1849   1806   
        }
 1850   1807   
        #[allow(missing_docs)] // documentation missing in model
 1851         -
        pub(crate) fn set_integer(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
 1852         -
            self.integer = input.map(|v| v.into());
        1808  +
        pub(crate) fn set_union(
        1809  +
            mut self,
        1810  +
            input: Option<impl ::std::convert::Into<crate::model::SimpleUnion>>,
        1811  +
        ) -> Self {
        1812  +
            self.union = input.map(|v| v.into());
 1853   1813   
            self
 1854   1814   
        }
 1855   1815   
        #[allow(missing_docs)] // documentation missing in model
 1856         -
        pub fn long(mut self, input: ::std::option::Option<i64>) -> Self {
 1857         -
            self.long = input;
        1816  +
        pub fn unit_union(mut self, input: ::std::option::Option<crate::model::UnitUnion>) -> Self {
        1817  +
            self.unit_union = input;
 1858   1818   
            self
 1859   1819   
        }
 1860   1820   
        #[allow(missing_docs)] // documentation missing in model
 1861         -
        pub(crate) fn set_long(mut self, input: Option<impl ::std::convert::Into<i64>>) -> Self {
 1862         -
            self.long = input.map(|v| v.into());
        1821  +
        pub(crate) fn set_unit_union(
        1822  +
            mut self,
        1823  +
            input: Option<impl ::std::convert::Into<crate::model::UnitUnion>>,
        1824  +
        ) -> Self {
        1825  +
            self.unit_union = input.map(|v| v.into());
 1863   1826   
            self
 1864   1827   
        }
 1865   1828   
        #[allow(missing_docs)] // documentation missing in model
 1866         -
        pub fn float(mut self, input: ::std::option::Option<f32>) -> Self {
 1867         -
            self.float = input;
        1829  +
        pub fn structure_list(
        1830  +
            mut self,
        1831  +
            input: ::std::option::Option<::std::vec::Vec<crate::model::SimpleStruct>>,
        1832  +
        ) -> Self {
        1833  +
            self.structure_list =
        1834  +
                input.map(|v| crate::constrained::MaybeConstrained::Constrained((v).into()));
 1868   1835   
            self
 1869   1836   
        }
 1870   1837   
        #[allow(missing_docs)] // documentation missing in model
 1871         -
        pub(crate) fn set_float(mut self, input: Option<impl ::std::convert::Into<f32>>) -> Self {
 1872         -
            self.float = input.map(|v| v.into());
        1838  +
        pub(crate) fn set_structure_list(
        1839  +
            mut self,
        1840  +
            input: Option<
        1841  +
                impl ::std::convert::Into<
        1842  +
                    crate::constrained::MaybeConstrained<
        1843  +
                        crate::constrained::struct_list_constrained::StructListConstrained,
        1844  +
                    >,
        1845  +
                >,
        1846  +
            >,
        1847  +
        ) -> Self {
        1848  +
            self.structure_list = input.map(|v| v.into());
 1873   1849   
            self
 1874   1850   
        }
 1875   1851   
        #[allow(missing_docs)] // documentation missing in model
 1876         -
        pub fn double(mut self, input: ::std::option::Option<f64>) -> Self {
 1877         -
            self.double = input;
        1852  +
        pub fn complex_list(
        1853  +
            mut self,
        1854  +
            input: ::std::vec::Vec<
        1855  +
                ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
        1856  +
            >,
        1857  +
        ) -> Self {
        1858  +
            self.complex_list = Some(crate::constrained::MaybeConstrained::Constrained(
        1859  +
                (input).into(),
        1860  +
            ));
 1878   1861   
            self
 1879   1862   
        }
 1880   1863   
        #[allow(missing_docs)] // documentation missing in model
 1881         -
        pub(crate) fn set_double(mut self, input: Option<impl ::std::convert::Into<f64>>) -> Self {
 1882         -
            self.double = input.map(|v| v.into());
        1864  +
        pub(crate) fn set_complex_list(
        1865  +
            mut self,
        1866  +
            input: impl ::std::convert::Into<
        1867  +
                crate::constrained::MaybeConstrained<
        1868  +
                    crate::constrained::complex_list_constrained::ComplexListConstrained,
        1869  +
                >,
        1870  +
            >,
        1871  +
        ) -> Self {
        1872  +
            self.complex_list = Some(input.into());
 1883   1873   
            self
 1884   1874   
        }
 1885   1875   
        #[allow(missing_docs)] // documentation missing in model
 1886         -
        pub fn timestamp(
        1876  +
        pub fn complex_map(
 1887   1877   
            mut self,
 1888         -
            input: ::std::option::Option<::aws_smithy_types::DateTime>,
        1878  +
            input: ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
 1889   1879   
        ) -> Self {
 1890         -
            self.timestamp = input;
        1880  +
            self.complex_map = Some(crate::constrained::MaybeConstrained::Constrained(
        1881  +
                (input).into(),
        1882  +
            ));
 1891   1883   
            self
 1892   1884   
        }
 1893   1885   
        #[allow(missing_docs)] // documentation missing in model
 1894         -
        pub(crate) fn set_timestamp(
        1886  +
        pub(crate) fn set_complex_map(
 1895   1887   
            mut self,
 1896         -
            input: Option<impl ::std::convert::Into<::aws_smithy_types::DateTime>>,
        1888  +
            input: impl ::std::convert::Into<
        1889  +
                crate::constrained::MaybeConstrained<
        1890  +
                    crate::constrained::complex_map_constrained::ComplexMapConstrained,
        1891  +
                >,
        1892  +
            >,
 1897   1893   
        ) -> Self {
 1898         -
            self.timestamp = input.map(|v| v.into());
        1894  +
            self.complex_map = Some(input.into());
 1899   1895   
            self
 1900   1896   
        }
 1901   1897   
        #[allow(missing_docs)] // documentation missing in model
 1902         -
        pub fn r#enum(mut self, input: ::std::option::Option<crate::model::Suit>) -> Self {
 1903         -
            self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
        1898  +
        #[allow(clippy::boxed_local)]
        1899  +
        pub fn complex_union(
        1900  +
            mut self,
        1901  +
            input: ::std::boxed::Box<crate::model::ComplexUnion>,
        1902  +
        ) -> Self {
        1903  +
            self.complex_union = Some(Box::new(crate::constrained::MaybeConstrained::Constrained(
        1904  +
                *input,
        1905  +
            )));
 1904   1906   
            self
 1905   1907   
        }
 1906   1908   
        #[allow(missing_docs)] // documentation missing in model
 1907         -
        pub(crate) fn set_enum(
        1909  +
        pub(crate) fn set_complex_union(
 1908   1910   
            mut self,
 1909         -
            input: Option<
 1910         -
                impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        1911  +
            input: impl ::std::convert::Into<
        1912  +
                ::std::boxed::Box<crate::constrained::MaybeConstrained<crate::model::ComplexUnion>>,
 1911   1913   
            >,
 1912   1914   
        ) -> Self {
 1913         -
            self.r#enum = input.map(|v| v.into());
        1915  +
            self.complex_union = Some(input.into());
 1914   1916   
            self
 1915   1917   
        }
        1918  +
        /// Consumes the builder and constructs a [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput).
        1919  +
        ///
        1920  +
        /// The builder fails to construct a [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput) if a [`ConstraintViolation`] occurs.
        1921  +
        ///
        1922  +
        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
        1923  +
        pub fn build(
        1924  +
            self,
        1925  +
        ) -> Result<crate::input::ComplexStructOperationInput, ConstraintViolation> {
        1926  +
            self.build_enforcing_all_constraints()
        1927  +
        }
        1928  +
        fn build_enforcing_all_constraints(
        1929  +
            self,
        1930  +
        ) -> Result<crate::input::ComplexStructOperationInput, ConstraintViolation> {
        1931  +
            Ok(crate::input::ComplexStructOperationInput {
        1932  +
                structure: self
        1933  +
                    .structure
        1934  +
                    .map(|v| match v {
        1935  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
        1936  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
        1937  +
                    })
        1938  +
                    .map(|res| res.map_err(ConstraintViolation::Structure))
        1939  +
                    .transpose()?,
        1940  +
                empty_structure: self.empty_structure,
        1941  +
                list: self.list,
        1942  +
                map: self.map,
        1943  +
                union: self.union,
        1944  +
                unit_union: self.unit_union,
        1945  +
                structure_list: self
        1946  +
                    .structure_list
        1947  +
                    .map(|v| match v {
        1948  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
        1949  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
        1950  +
                    })
        1951  +
                    .map(|res| {
        1952  +
                        res.map(|v| v.into())
        1953  +
                            .map_err(ConstraintViolation::StructureList)
        1954  +
                    })
        1955  +
                    .transpose()?,
        1956  +
                complex_list: self
        1957  +
                    .complex_list
        1958  +
                    .map(|v| match v {
        1959  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
        1960  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
        1961  +
                    })
        1962  +
                    .map(|res| {
        1963  +
                        res.map(|v| v.into())
        1964  +
                            .map_err(ConstraintViolation::ComplexList)
        1965  +
                    })
        1966  +
                    .transpose()?
        1967  +
                    .ok_or(ConstraintViolation::MissingComplexList)?,
        1968  +
                complex_map: self
        1969  +
                    .complex_map
        1970  +
                    .map(|v| match v {
        1971  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
        1972  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
        1973  +
                    })
        1974  +
                    .map(|res| {
        1975  +
                        res.map(|v| v.into())
        1976  +
                            .map_err(ConstraintViolation::ComplexMap)
        1977  +
                    })
        1978  +
                    .transpose()?
        1979  +
                    .ok_or(ConstraintViolation::MissingComplexMap)?,
        1980  +
                complex_union: self
        1981  +
                    .complex_union
        1982  +
                    .map(|v| match *v {
        1983  +
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(Box::new(x)),
        1984  +
                        crate::constrained::MaybeConstrained::Unconstrained(x) => {
        1985  +
                            Ok(Box::new(x.try_into()?))
        1986  +
                        }
        1987  +
                    })
        1988  +
                    .map(|res| {
        1989  +
                        res.map_err(Box::new)
        1990  +
                            .map_err(ConstraintViolation::ComplexUnion)
        1991  +
                    })
        1992  +
                    .transpose()?
        1993  +
                    .ok_or(ConstraintViolation::MissingComplexUnion)?,
        1994  +
            })
        1995  +
        }
        1996  +
    }
        1997  +
}
        1998  +
/// See [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
        1999  +
pub mod empty_struct_operation_input {
        2000  +
        2001  +
    impl ::std::convert::From<Builder> for crate::input::EmptyStructOperationInput {
        2002  +
        fn from(builder: Builder) -> Self {
        2003  +
            builder.build()
        2004  +
        }
        2005  +
    }
        2006  +
    /// A builder for [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
        2007  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        2008  +
    pub struct Builder {}
        2009  +
    impl Builder {
        2010  +
        /// Consumes the builder and constructs a [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput).
        2011  +
        pub fn build(self) -> crate::input::EmptyStructOperationInput {
        2012  +
            self.build_enforcing_all_constraints()
        2013  +
        }
        2014  +
        fn build_enforcing_all_constraints(self) -> crate::input::EmptyStructOperationInput {
        2015  +
            crate::input::EmptyStructOperationInput {}
        2016  +
        }
        2017  +
    }
        2018  +
}
        2019  +
/// See [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
        2020  +
pub mod single_member_struct_operation_input {
        2021  +
        2022  +
    impl ::std::convert::From<Builder> for crate::input::SingleMemberStructOperationInput {
        2023  +
        fn from(builder: Builder) -> Self {
        2024  +
            builder.build()
        2025  +
        }
        2026  +
    }
        2027  +
    /// A builder for [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
        2028  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        2029  +
    pub struct Builder {
        2030  +
        pub(crate) message: ::std::option::Option<::std::string::String>,
        2031  +
    }
        2032  +
    impl Builder {
 1916   2033   
        #[allow(missing_docs)] // documentation missing in model
 1917         -
        pub fn required_blob(mut self, input: ::aws_smithy_types::Blob) -> Self {
 1918         -
            self.required_blob = Some(input);
        2034  +
        pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        2035  +
            self.message = input;
 1919   2036   
            self
 1920   2037   
        }
 1921   2038   
        #[allow(missing_docs)] // documentation missing in model
 1922         -
        pub(crate) fn set_required_blob(
        2039  +
        pub(crate) fn set_message(
 1923   2040   
            mut self,
 1924         -
            input: impl ::std::convert::Into<::aws_smithy_types::Blob>,
        2041  +
            input: Option<impl ::std::convert::Into<::std::string::String>>,
 1925   2042   
        ) -> Self {
 1926         -
            self.required_blob = Some(input.into());
        2043  +
            self.message = input.map(|v| v.into());
 1927   2044   
            self
 1928   2045   
        }
 1929         -
        #[allow(missing_docs)] // documentation missing in model
 1930         -
        pub fn required_boolean(mut self, input: bool) -> Self {
 1931         -
            self.required_boolean = Some(input);
 1932         -
            self
        2046  +
        /// Consumes the builder and constructs a [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput).
        2047  +
        pub fn build(self) -> crate::input::SingleMemberStructOperationInput {
        2048  +
            self.build_enforcing_all_constraints()
        2049  +
        }
        2050  +
        fn build_enforcing_all_constraints(self) -> crate::input::SingleMemberStructOperationInput {
        2051  +
            crate::input::SingleMemberStructOperationInput {
        2052  +
                message: self.message,
        2053  +
            }
        2054  +
        }
        2055  +
    }
        2056  +
}
        2057  +
/// See [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
        2058  +
pub mod recursive_union_operation_input {
        2059  +
        2060  +
    impl ::std::convert::From<Builder> for crate::input::RecursiveUnionOperationInput {
        2061  +
        fn from(builder: Builder) -> Self {
        2062  +
            builder.build()
 1933   2063   
        }
        2064  +
    }
        2065  +
    /// A builder for [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
        2066  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        2067  +
    pub struct Builder {
        2068  +
        pub(crate) nested:
        2069  +
            ::std::option::Option<crate::model::RecursiveOperationInputOutputNested1>,
        2070  +
    }
        2071  +
    impl Builder {
 1934   2072   
        #[allow(missing_docs)] // documentation missing in model
 1935         -
        pub(crate) fn set_required_boolean(
        2073  +
        pub fn nested(
 1936   2074   
            mut self,
 1937         -
            input: impl ::std::convert::Into<bool>,
        2075  +
            input: ::std::option::Option<crate::model::RecursiveOperationInputOutputNested1>,
 1938   2076   
        ) -> Self {
 1939         -
            self.required_boolean = Some(input.into());
 1940         -
            self
 1941         -
        }
 1942         -
        #[allow(missing_docs)] // documentation missing in model
 1943         -
        pub fn required_string(mut self, input: ::std::string::String) -> Self {
 1944         -
            self.required_string = Some(input);
        2077  +
            self.nested = input;
 1945   2078   
            self
 1946   2079   
        }
 1947   2080   
        #[allow(missing_docs)] // documentation missing in model
 1948         -
        pub(crate) fn set_required_string(
        2081  +
        pub(crate) fn set_nested(
 1949   2082   
            mut self,
 1950         -
            input: impl ::std::convert::Into<::std::string::String>,
        2083  +
            input: Option<
        2084  +
                impl ::std::convert::Into<crate::model::RecursiveOperationInputOutputNested1>,
        2085  +
            >,
 1951   2086   
        ) -> Self {
 1952         -
            self.required_string = Some(input.into());
        2087  +
            self.nested = input.map(|v| v.into());
 1953   2088   
            self
 1954   2089   
        }
 1955         -
        #[allow(missing_docs)] // documentation missing in model
 1956         -
        pub fn required_byte(mut self, input: i8) -> Self {
 1957         -
            self.required_byte = Some(input);
 1958         -
            self
        2090  +
        /// Consumes the builder and constructs a [`RecursiveUnionOperationInput`](crate::input::RecursiveUnionOperationInput).
        2091  +
        pub fn build(self) -> crate::input::RecursiveUnionOperationInput {
        2092  +
            self.build_enforcing_all_constraints()
 1959   2093   
        }
 1960         -
        #[allow(missing_docs)] // documentation missing in model
 1961         -
        pub(crate) fn set_required_byte(mut self, input: impl ::std::convert::Into<i8>) -> Self {
 1962         -
            self.required_byte = Some(input.into());
 1963         -
            self
        2094  +
        fn build_enforcing_all_constraints(self) -> crate::input::RecursiveUnionOperationInput {
        2095  +
            crate::input::RecursiveUnionOperationInput {
        2096  +
                nested: self.nested,
        2097  +
            }
 1964   2098   
        }
 1965         -
        #[allow(missing_docs)] // documentation missing in model
 1966         -
        pub fn required_short(mut self, input: i16) -> Self {
 1967         -
            self.required_short = Some(input);
 1968         -
            self
        2099  +
    }
        2100  +
}
        2101  +
/// See [`StreamingOperationInput`](crate::input::StreamingOperationInput).
        2102  +
pub mod streaming_operation_input {
        2103  +
        2104  +
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
        2105  +
    /// Holds one variant for each of the ways the builder can fail.
        2106  +
    #[non_exhaustive]
        2107  +
    #[allow(clippy::enum_variant_names)]
        2108  +
    pub enum ConstraintViolation {
        2109  +
        /// `events` was not provided but it is required when building `StreamingOperationInput`.
        2110  +
        MissingEvents,
        2111  +
    }
        2112  +
    impl ::std::fmt::Display for ConstraintViolation {
        2113  +
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        2114  +
            match self {
        2115  +
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationInput`"),
        2116  +
            }
 1969   2117   
        }
 1970         -
        #[allow(missing_docs)] // documentation missing in model
 1971         -
        pub(crate) fn set_required_short(mut self, input: impl ::std::convert::Into<i16>) -> Self {
 1972         -
            self.required_short = Some(input.into());
 1973         -
            self
        2118  +
    }
        2119  +
    impl ::std::error::Error for ConstraintViolation {}
        2120  +
    impl ConstraintViolation {
        2121  +
        pub(crate) fn as_validation_exception_field(
        2122  +
            self,
        2123  +
            path: ::std::string::String,
        2124  +
        ) -> crate::model::ValidationExceptionField {
        2125  +
            match self {
        2126  +
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
        2127  +
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
        2128  +
                                                path: path + "/events",
        2129  +
                                            },
 1974   2130   
        }
 1975         -
        #[allow(missing_docs)] // documentation missing in model
 1976         -
        pub fn required_integer(mut self, input: i32) -> Self {
 1977         -
            self.required_integer = Some(input);
 1978         -
            self
 1979   2131   
        }
        2132  +
    }
        2133  +
    impl ::std::convert::From<ConstraintViolation>
        2134  +
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
        2135  +
    {
        2136  +
        fn from(constraint_violation: ConstraintViolation) -> Self {
        2137  +
            let first_validation_exception_field =
        2138  +
                constraint_violation.as_validation_exception_field("".to_owned());
        2139  +
            let validation_exception = crate::error::ValidationException {
        2140  +
                message: format!(
        2141  +
                    "1 validation error detected. {}",
        2142  +
                    &first_validation_exception_field.message
        2143  +
                ),
        2144  +
                field_list: Some(vec![first_validation_exception_field]),
        2145  +
            };
        2146  +
            Self::ConstraintViolation(
        2147  +
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
        2148  +
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
        2149  +
                            )
        2150  +
        }
        2151  +
    }
        2152  +
    impl ::std::convert::From<Builder>
        2153  +
        for crate::constrained::MaybeConstrained<crate::input::StreamingOperationInput>
        2154  +
    {
        2155  +
        fn from(builder: Builder) -> Self {
        2156  +
            Self::Unconstrained(builder)
        2157  +
        }
        2158  +
    }
        2159  +
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationInput {
        2160  +
        type Error = ConstraintViolation;
        2161  +
        2162  +
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
        2163  +
            builder.build()
        2164  +
        }
        2165  +
    }
        2166  +
    /// A builder for [`StreamingOperationInput`](crate::input::StreamingOperationInput).
        2167  +
    #[derive(::std::default::Default, ::std::fmt::Debug)]
        2168  +
    pub struct Builder {
        2169  +
        pub(crate) events: ::std::option::Option<
        2170  +
            crate::sigv4_event_stream::SigV4Receiver<
        2171  +
                crate::model::Events,
        2172  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2173  +
            >,
        2174  +
        >,
        2175  +
    }
        2176  +
    impl Builder {
 1980   2177   
        #[allow(missing_docs)] // documentation missing in model
 1981         -
        pub(crate) fn set_required_integer(
        2178  +
        pub fn events(
 1982   2179   
            mut self,
 1983         -
            input: impl ::std::convert::Into<i32>,
        2180  +
            input: crate::sigv4_event_stream::SigV4Receiver<
        2181  +
                crate::model::Events,
        2182  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2183  +
            >,
 1984   2184   
        ) -> Self {
 1985         -
            self.required_integer = Some(input.into());
        2185  +
            self.events = Some(input);
 1986   2186   
            self
 1987   2187   
        }
 1988   2188   
        #[allow(missing_docs)] // documentation missing in model
 1989         -
        pub fn required_long(mut self, input: i64) -> Self {
 1990         -
            self.required_long = Some(input);
        2189  +
        pub(crate) fn set_events(
        2190  +
            mut self,
        2191  +
            input: impl ::std::convert::Into<
        2192  +
                crate::sigv4_event_stream::SigV4Receiver<
        2193  +
                    crate::model::Events,
        2194  +
                    ::aws_smithy_http::event_stream::MessageStreamError,
        2195  +
                >,
        2196  +
            >,
        2197  +
        ) -> Self {
        2198  +
            self.events = Some(input.into());
 1991   2199   
            self
 1992   2200   
        }
 1993         -
        #[allow(missing_docs)] // documentation missing in model
 1994         -
        pub(crate) fn set_required_long(mut self, input: impl ::std::convert::Into<i64>) -> Self {
 1995         -
            self.required_long = Some(input.into());
 1996         -
            self
        2201  +
        /// Consumes the builder and constructs a [`StreamingOperationInput`](crate::input::StreamingOperationInput).
        2202  +
        ///
        2203  +
        /// The builder fails to construct a [`StreamingOperationInput`](crate::input::StreamingOperationInput) if a [`ConstraintViolation`] occurs.
        2204  +
        ///
        2205  +
        pub fn build(self) -> Result<crate::input::StreamingOperationInput, ConstraintViolation> {
        2206  +
            self.build_enforcing_all_constraints()
 1997   2207   
        }
 1998         -
        #[allow(missing_docs)] // documentation missing in model
 1999         -
        pub fn required_float(mut self, input: f32) -> Self {
 2000         -
            self.required_float = Some(input);
 2001         -
            self
        2208  +
        fn build_enforcing_all_constraints(
        2209  +
            self,
        2210  +
        ) -> Result<crate::input::StreamingOperationInput, ConstraintViolation> {
        2211  +
            Ok(crate::input::StreamingOperationInput {
        2212  +
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
        2213  +
            })
 2002   2214   
        }
 2003         -
        #[allow(missing_docs)] // documentation missing in model
 2004         -
        pub(crate) fn set_required_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
 2005         -
            self.required_float = Some(input.into());
 2006         -
            self
        2215  +
    }
        2216  +
}
        2217  +
/// See [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
        2218  +
pub mod streaming_operation_with_initial_data_input {
        2219  +
        2220  +
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
        2221  +
    /// Holds one variant for each of the ways the builder can fail.
        2222  +
    #[non_exhaustive]
        2223  +
    #[allow(clippy::enum_variant_names)]
        2224  +
    pub enum ConstraintViolation {
        2225  +
        /// `initial_data` was not provided but it is required when building `StreamingOperationWithInitialDataInput`.
        2226  +
        MissingInitialData,
        2227  +
        /// `events` was not provided but it is required when building `StreamingOperationWithInitialDataInput`.
        2228  +
        MissingEvents,
        2229  +
    }
        2230  +
    impl ::std::fmt::Display for ConstraintViolation {
        2231  +
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        2232  +
            match self {
        2233  +
                ConstraintViolation::MissingInitialData => write!(f, "`initial_data` was not provided but it is required when building `StreamingOperationWithInitialDataInput`"),
        2234  +
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationWithInitialDataInput`"),
        2235  +
            }
        2236  +
        }
        2237  +
    }
        2238  +
    impl ::std::error::Error for ConstraintViolation {}
        2239  +
    impl ConstraintViolation {
        2240  +
        pub(crate) fn as_validation_exception_field(
        2241  +
            self,
        2242  +
            path: ::std::string::String,
        2243  +
        ) -> crate::model::ValidationExceptionField {
        2244  +
            match self {
        2245  +
            ConstraintViolation::MissingInitialData => crate::model::ValidationExceptionField {
        2246  +
                                                message: format!("Value at '{}/initialData' failed to satisfy constraint: Member must not be null", path),
        2247  +
                                                path: path + "/initialData",
        2248  +
                                            },
        2249  +
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
        2250  +
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
        2251  +
                                                path: path + "/events",
        2252  +
                                            },
        2253  +
        }
        2254  +
        }
        2255  +
    }
        2256  +
    impl ::std::convert::From<ConstraintViolation>
        2257  +
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
        2258  +
    {
        2259  +
        fn from(constraint_violation: ConstraintViolation) -> Self {
        2260  +
            let first_validation_exception_field =
        2261  +
                constraint_violation.as_validation_exception_field("".to_owned());
        2262  +
            let validation_exception = crate::error::ValidationException {
        2263  +
                message: format!(
        2264  +
                    "1 validation error detected. {}",
        2265  +
                    &first_validation_exception_field.message
        2266  +
                ),
        2267  +
                field_list: Some(vec![first_validation_exception_field]),
        2268  +
            };
        2269  +
            Self::ConstraintViolation(
        2270  +
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
        2271  +
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
        2272  +
                            )
 2007   2273   
        }
 2008         -
        #[allow(missing_docs)] // documentation missing in model
 2009         -
        pub fn required_double(mut self, input: f64) -> Self {
 2010         -
            self.required_double = Some(input);
 2011         -
            self
        2274  +
    }
        2275  +
    impl ::std::convert::From<Builder>
        2276  +
        for crate::constrained::MaybeConstrained<
        2277  +
            crate::input::StreamingOperationWithInitialDataInput,
        2278  +
        >
        2279  +
    {
        2280  +
        fn from(builder: Builder) -> Self {
        2281  +
            Self::Unconstrained(builder)
 2012   2282   
        }
 2013         -
        #[allow(missing_docs)] // documentation missing in model
 2014         -
        pub(crate) fn set_required_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
 2015         -
            self.required_double = Some(input.into());
 2016         -
            self
        2283  +
    }
        2284  +
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationWithInitialDataInput {
        2285  +
        type Error = ConstraintViolation;
        2286  +
        2287  +
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
        2288  +
            builder.build()
 2017   2289   
        }
        2290  +
    }
        2291  +
    /// A builder for [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
        2292  +
    #[derive(::std::default::Default, ::std::fmt::Debug)]
        2293  +
    pub struct Builder {
        2294  +
        pub(crate) initial_data: ::std::option::Option<::std::string::String>,
        2295  +
        pub(crate) events: ::std::option::Option<
        2296  +
            crate::sigv4_event_stream::SigV4Receiver<
        2297  +
                crate::model::Events,
        2298  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2299  +
            >,
        2300  +
        >,
        2301  +
    }
        2302  +
    impl Builder {
 2018   2303   
        #[allow(missing_docs)] // documentation missing in model
 2019         -
        pub fn required_timestamp(mut self, input: ::aws_smithy_types::DateTime) -> Self {
 2020         -
            self.required_timestamp = Some(input);
        2304  +
        pub fn initial_data(mut self, input: ::std::string::String) -> Self {
        2305  +
            self.initial_data = Some(input);
 2021   2306   
            self
 2022   2307   
        }
 2023   2308   
        #[allow(missing_docs)] // documentation missing in model
 2024         -
        pub(crate) fn set_required_timestamp(
        2309  +
        pub(crate) fn set_initial_data(
 2025   2310   
            mut self,
 2026         -
            input: impl ::std::convert::Into<::aws_smithy_types::DateTime>,
        2311  +
            input: impl ::std::convert::Into<::std::string::String>,
 2027   2312   
        ) -> Self {
 2028         -
            self.required_timestamp = Some(input.into());
        2313  +
            self.initial_data = Some(input.into());
 2029   2314   
            self
 2030   2315   
        }
 2031   2316   
        #[allow(missing_docs)] // documentation missing in model
 2032         -
        pub fn required_enum(mut self, input: crate::model::Suit) -> Self {
 2033         -
            self.required_enum = Some(crate::constrained::MaybeConstrained::Constrained(input));
        2317  +
        pub fn events(
        2318  +
            mut self,
        2319  +
            input: crate::sigv4_event_stream::SigV4Receiver<
        2320  +
                crate::model::Events,
        2321  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2322  +
            >,
        2323  +
        ) -> Self {
        2324  +
            self.events = Some(input);
 2034   2325   
            self
 2035   2326   
        }
 2036   2327   
        #[allow(missing_docs)] // documentation missing in model
 2037         -
        pub(crate) fn set_required_enum(
        2328  +
        pub(crate) fn set_events(
 2038   2329   
            mut self,
 2039         -
            input: impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        2330  +
            input: impl ::std::convert::Into<
        2331  +
                crate::sigv4_event_stream::SigV4Receiver<
        2332  +
                    crate::model::Events,
        2333  +
                    ::aws_smithy_http::event_stream::MessageStreamError,
        2334  +
                >,
        2335  +
            >,
 2040   2336   
        ) -> Self {
 2041         -
            self.required_enum = Some(input.into());
        2337  +
            self.events = Some(input.into());
 2042   2338   
            self
 2043   2339   
        }
 2044         -
        /// Consumes the builder and constructs a [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput).
        2340  +
        /// Consumes the builder and constructs a [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput).
 2045   2341   
        ///
 2046         -
        /// The builder fails to construct a [`ErrorSerializationOperationInput`](crate::input::ErrorSerializationOperationInput) if a [`ConstraintViolation`] occurs.
        2342  +
        /// The builder fails to construct a [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput) if a [`ConstraintViolation`] occurs.
 2047   2343   
        ///
 2048   2344   
        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
 2049   2345   
        pub fn build(
 2050   2346   
            self,
 2051         -
        ) -> Result<crate::input::ErrorSerializationOperationInput, ConstraintViolation> {
        2347  +
        ) -> Result<crate::input::StreamingOperationWithInitialDataInput, ConstraintViolation>
        2348  +
        {
 2052   2349   
            self.build_enforcing_all_constraints()
 2053   2350   
        }
 2054   2351   
        fn build_enforcing_all_constraints(
 2055   2352   
            self,
 2056         -
        ) -> Result<crate::input::ErrorSerializationOperationInput, ConstraintViolation> {
 2057         -
            Ok(crate::input::ErrorSerializationOperationInput {
 2058         -
                blob: self.blob,
 2059         -
                boolean: self.boolean,
 2060         -
                string: self.string,
 2061         -
                byte: self.byte,
 2062         -
                short: self.short,
 2063         -
                integer: self.integer,
 2064         -
                long: self.long,
 2065         -
                float: self.float,
 2066         -
                double: self.double,
 2067         -
                timestamp: self.timestamp,
 2068         -
                r#enum: self
 2069         -
                    .r#enum
 2070         -
                    .map(|v| match v {
 2071         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 2072         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 2073         -
                    })
 2074         -
                    .map(|res| res.map_err(ConstraintViolation::Enum))
 2075         -
                    .transpose()?,
 2076         -
                required_blob: self
 2077         -
                    .required_blob
 2078         -
                    .ok_or(ConstraintViolation::MissingRequiredBlob)?,
 2079         -
                required_boolean: self
 2080         -
                    .required_boolean
 2081         -
                    .ok_or(ConstraintViolation::MissingRequiredBoolean)?,
 2082         -
                required_string: self
 2083         -
                    .required_string
 2084         -
                    .ok_or(ConstraintViolation::MissingRequiredString)?,
 2085         -
                required_byte: self
 2086         -
                    .required_byte
 2087         -
                    .ok_or(ConstraintViolation::MissingRequiredByte)?,
 2088         -
                required_short: self
 2089         -
                    .required_short
 2090         -
                    .ok_or(ConstraintViolation::MissingRequiredShort)?,
 2091         -
                required_integer: self
 2092         -
                    .required_integer
 2093         -
                    .ok_or(ConstraintViolation::MissingRequiredInteger)?,
 2094         -
                required_long: self
 2095         -
                    .required_long
 2096         -
                    .ok_or(ConstraintViolation::MissingRequiredLong)?,
 2097         -
                required_float: self
 2098         -
                    .required_float
 2099         -
                    .ok_or(ConstraintViolation::MissingRequiredFloat)?,
 2100         -
                required_double: self
 2101         -
                    .required_double
 2102         -
                    .ok_or(ConstraintViolation::MissingRequiredDouble)?,
 2103         -
                required_timestamp: self
 2104         -
                    .required_timestamp
 2105         -
                    .ok_or(ConstraintViolation::MissingRequiredTimestamp)?,
 2106         -
                required_enum: self
 2107         -
                    .required_enum
 2108         -
                    .map(|v| match v {
 2109         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 2110         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 2111         -
                    })
 2112         -
                    .map(|res| res.map_err(ConstraintViolation::RequiredEnum))
 2113         -
                    .transpose()?
 2114         -
                    .ok_or(ConstraintViolation::MissingRequiredEnum)?,
        2353  +
        ) -> Result<crate::input::StreamingOperationWithInitialDataInput, ConstraintViolation>
        2354  +
        {
        2355  +
            Ok(crate::input::StreamingOperationWithInitialDataInput {
        2356  +
                initial_data: self
        2357  +
                    .initial_data
        2358  +
                    .ok_or(ConstraintViolation::MissingInitialData)?,
        2359  +
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
 2115   2360   
            })
 2116   2361   
        }
 2117         -
    }
 2118         -
}
 2119         -
/// See [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
 2120         -
pub mod simple_struct_operation_input {
 2121         -
 2122         -
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
 2123         -
    /// Holds one variant for each of the ways the builder can fail.
 2124         -
    #[non_exhaustive]
 2125         -
    #[allow(clippy::enum_variant_names)]
 2126         -
    pub enum ConstraintViolation {
 2127         -
        /// Constraint violation occurred building member `r#enum` when building `SimpleStructOperationInput`.
 2128         -
        #[doc(hidden)]
 2129         -
        Enum(crate::model::suit::ConstraintViolation),
 2130         -
        /// `required_blob` was not provided but it is required when building `SimpleStructOperationInput`.
 2131         -
        MissingRequiredBlob,
 2132         -
        /// `required_boolean` was not provided but it is required when building `SimpleStructOperationInput`.
 2133         -
        MissingRequiredBoolean,
 2134         -
        /// `required_string` was not provided but it is required when building `SimpleStructOperationInput`.
 2135         -
        MissingRequiredString,
 2136         -
        /// `required_byte` was not provided but it is required when building `SimpleStructOperationInput`.
 2137         -
        MissingRequiredByte,
 2138         -
        /// `required_short` was not provided but it is required when building `SimpleStructOperationInput`.
 2139         -
        MissingRequiredShort,
 2140         -
        /// `required_integer` was not provided but it is required when building `SimpleStructOperationInput`.
 2141         -
        MissingRequiredInteger,
 2142         -
        /// `required_long` was not provided but it is required when building `SimpleStructOperationInput`.
 2143         -
        MissingRequiredLong,
 2144         -
        /// `required_float` was not provided but it is required when building `SimpleStructOperationInput`.
 2145         -
        MissingRequiredFloat,
 2146         -
        /// `required_double` was not provided but it is required when building `SimpleStructOperationInput`.
 2147         -
        MissingRequiredDouble,
 2148         -
        /// `required_timestamp` was not provided but it is required when building `SimpleStructOperationInput`.
 2149         -
        MissingRequiredTimestamp,
 2150         -
        /// `required_enum` was not provided but it is required when building `SimpleStructOperationInput`.
 2151         -
        MissingRequiredEnum,
 2152         -
        /// Constraint violation occurred building member `required_enum` when building `SimpleStructOperationInput`.
 2153         -
        #[doc(hidden)]
 2154         -
        RequiredEnum(crate::model::suit::ConstraintViolation),
 2155         -
    }
 2156         -
    impl ::std::fmt::Display for ConstraintViolation {
 2157         -
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2158         -
            match self {
 2159         -
                ConstraintViolation::Enum(_) => write!(f, "constraint violation occurred building member `r#enum` when building `SimpleStructOperationInput`"),
 2160         -
                ConstraintViolation::MissingRequiredBlob => write!(f, "`required_blob` was not provided but it is required when building `SimpleStructOperationInput`"),
 2161         -
                ConstraintViolation::MissingRequiredBoolean => write!(f, "`required_boolean` was not provided but it is required when building `SimpleStructOperationInput`"),
 2162         -
                ConstraintViolation::MissingRequiredString => write!(f, "`required_string` was not provided but it is required when building `SimpleStructOperationInput`"),
 2163         -
                ConstraintViolation::MissingRequiredByte => write!(f, "`required_byte` was not provided but it is required when building `SimpleStructOperationInput`"),
 2164         -
                ConstraintViolation::MissingRequiredShort => write!(f, "`required_short` was not provided but it is required when building `SimpleStructOperationInput`"),
 2165         -
                ConstraintViolation::MissingRequiredInteger => write!(f, "`required_integer` was not provided but it is required when building `SimpleStructOperationInput`"),
 2166         -
                ConstraintViolation::MissingRequiredLong => write!(f, "`required_long` was not provided but it is required when building `SimpleStructOperationInput`"),
 2167         -
                ConstraintViolation::MissingRequiredFloat => write!(f, "`required_float` was not provided but it is required when building `SimpleStructOperationInput`"),
 2168         -
                ConstraintViolation::MissingRequiredDouble => write!(f, "`required_double` was not provided but it is required when building `SimpleStructOperationInput`"),
 2169         -
                ConstraintViolation::MissingRequiredTimestamp => write!(f, "`required_timestamp` was not provided but it is required when building `SimpleStructOperationInput`"),
 2170         -
                ConstraintViolation::MissingRequiredEnum => write!(f, "`required_enum` was not provided but it is required when building `SimpleStructOperationInput`"),
 2171         -
                ConstraintViolation::RequiredEnum(_) => write!(f, "constraint violation occurred building member `required_enum` when building `SimpleStructOperationInput`"),
 2172         -
            }
 2173         -
        }
 2174         -
    }
 2175         -
    impl ::std::error::Error for ConstraintViolation {}
 2176         -
    impl ConstraintViolation {
 2177         -
        pub(crate) fn as_validation_exception_field(
 2178         -
            self,
 2179         -
            path: ::std::string::String,
 2180         -
        ) -> crate::model::ValidationExceptionField {
 2181         -
            match self {
 2182         -
            ConstraintViolation::Enum(inner) => inner.as_validation_exception_field(path + "/enum"),
 2183         -
            ConstraintViolation::MissingRequiredBlob => crate::model::ValidationExceptionField {
 2184         -
                                                message: format!("Value at '{}/requiredBlob' failed to satisfy constraint: Member must not be null", path),
 2185         -
                                                path: path + "/requiredBlob",
 2186         -
                                            },
 2187         -
            ConstraintViolation::MissingRequiredBoolean => crate::model::ValidationExceptionField {
 2188         -
                                                message: format!("Value at '{}/requiredBoolean' failed to satisfy constraint: Member must not be null", path),
 2189         -
                                                path: path + "/requiredBoolean",
 2190         -
                                            },
 2191         -
            ConstraintViolation::MissingRequiredString => crate::model::ValidationExceptionField {
 2192         -
                                                message: format!("Value at '{}/requiredString' failed to satisfy constraint: Member must not be null", path),
 2193         -
                                                path: path + "/requiredString",
 2194         -
                                            },
 2195         -
            ConstraintViolation::MissingRequiredByte => crate::model::ValidationExceptionField {
 2196         -
                                                message: format!("Value at '{}/requiredByte' failed to satisfy constraint: Member must not be null", path),
 2197         -
                                                path: path + "/requiredByte",
 2198         -
                                            },
 2199         -
            ConstraintViolation::MissingRequiredShort => crate::model::ValidationExceptionField {
 2200         -
                                                message: format!("Value at '{}/requiredShort' failed to satisfy constraint: Member must not be null", path),
 2201         -
                                                path: path + "/requiredShort",
 2202         -
                                            },
 2203         -
            ConstraintViolation::MissingRequiredInteger => crate::model::ValidationExceptionField {
 2204         -
                                                message: format!("Value at '{}/requiredInteger' failed to satisfy constraint: Member must not be null", path),
 2205         -
                                                path: path + "/requiredInteger",
 2206         -
                                            },
 2207         -
            ConstraintViolation::MissingRequiredLong => crate::model::ValidationExceptionField {
 2208         -
                                                message: format!("Value at '{}/requiredLong' failed to satisfy constraint: Member must not be null", path),
 2209         -
                                                path: path + "/requiredLong",
 2210         -
                                            },
 2211         -
            ConstraintViolation::MissingRequiredFloat => crate::model::ValidationExceptionField {
 2212         -
                                                message: format!("Value at '{}/requiredFloat' failed to satisfy constraint: Member must not be null", path),
 2213         -
                                                path: path + "/requiredFloat",
 2214         -
                                            },
 2215         -
            ConstraintViolation::MissingRequiredDouble => crate::model::ValidationExceptionField {
 2216         -
                                                message: format!("Value at '{}/requiredDouble' failed to satisfy constraint: Member must not be null", path),
 2217         -
                                                path: path + "/requiredDouble",
 2218         -
                                            },
 2219         -
            ConstraintViolation::MissingRequiredTimestamp => crate::model::ValidationExceptionField {
 2220         -
                                                message: format!("Value at '{}/requiredTimestamp' failed to satisfy constraint: Member must not be null", path),
 2221         -
                                                path: path + "/requiredTimestamp",
 2222         -
                                            },
 2223         -
            ConstraintViolation::MissingRequiredEnum => crate::model::ValidationExceptionField {
 2224         -
                                                message: format!("Value at '{}/requiredEnum' failed to satisfy constraint: Member must not be null", path),
 2225         -
                                                path: path + "/requiredEnum",
        2362  +
    }
        2363  +
}
        2364  +
/// See [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
        2365  +
pub mod streaming_operation_with_initial_response_input {
        2366  +
        2367  +
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
        2368  +
    /// Holds one variant for each of the ways the builder can fail.
        2369  +
    #[non_exhaustive]
        2370  +
    #[allow(clippy::enum_variant_names)]
        2371  +
    pub enum ConstraintViolation {
        2372  +
        /// `events` was not provided but it is required when building `StreamingOperationWithInitialResponseInput`.
        2373  +
        MissingEvents,
        2374  +
    }
        2375  +
    impl ::std::fmt::Display for ConstraintViolation {
        2376  +
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        2377  +
            match self {
        2378  +
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationWithInitialResponseInput`"),
        2379  +
            }
        2380  +
        }
        2381  +
    }
        2382  +
    impl ::std::error::Error for ConstraintViolation {}
        2383  +
    impl ConstraintViolation {
        2384  +
        pub(crate) fn as_validation_exception_field(
        2385  +
            self,
        2386  +
            path: ::std::string::String,
        2387  +
        ) -> crate::model::ValidationExceptionField {
        2388  +
            match self {
        2389  +
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
        2390  +
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
        2391  +
                                                path: path + "/events",
 2226   2392   
                                            },
 2227         -
            ConstraintViolation::RequiredEnum(inner) => inner.as_validation_exception_field(path + "/requiredEnum"),
 2228   2393   
        }
 2229   2394   
        }
 2230   2395   
    }
 2231   2396   
    impl ::std::convert::From<ConstraintViolation>
 2232   2397   
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
 2233   2398   
    {
 2234   2399   
        fn from(constraint_violation: ConstraintViolation) -> Self {
 2235   2400   
            let first_validation_exception_field =
 2236   2401   
                constraint_violation.as_validation_exception_field("".to_owned());
 2237   2402   
            let validation_exception = crate::error::ValidationException {
 2238   2403   
                message: format!(
 2239   2404   
                    "1 validation error detected. {}",
 2240   2405   
                    &first_validation_exception_field.message
 2241   2406   
                ),
 2242   2407   
                field_list: Some(vec![first_validation_exception_field]),
 2243   2408   
            };
 2244   2409   
            Self::ConstraintViolation(
 2245   2410   
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
 2246   2411   
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
 2247   2412   
                            )
 2248   2413   
        }
 2249   2414   
    }
 2250   2415   
    impl ::std::convert::From<Builder>
 2251         -
        for crate::constrained::MaybeConstrained<crate::input::SimpleStructOperationInput>
        2416  +
        for crate::constrained::MaybeConstrained<
        2417  +
            crate::input::StreamingOperationWithInitialResponseInput,
        2418  +
        >
 2252   2419   
    {
 2253   2420   
        fn from(builder: Builder) -> Self {
 2254   2421   
            Self::Unconstrained(builder)
 2255   2422   
        }
 2256   2423   
    }
 2257         -
    impl ::std::convert::TryFrom<Builder> for crate::input::SimpleStructOperationInput {
        2424  +
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationWithInitialResponseInput {
 2258   2425   
        type Error = ConstraintViolation;
 2259   2426   
 2260   2427   
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
 2261   2428   
            builder.build()
 2262   2429   
        }
 2263         -
    }
 2264         -
    /// A builder for [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
 2265         -
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 2266         -
    pub struct Builder {
 2267         -
        pub(crate) blob: ::std::option::Option<::aws_smithy_types::Blob>,
 2268         -
        pub(crate) boolean: ::std::option::Option<bool>,
 2269         -
        pub(crate) string: ::std::option::Option<::std::string::String>,
 2270         -
        pub(crate) byte: ::std::option::Option<i8>,
 2271         -
        pub(crate) short: ::std::option::Option<i16>,
 2272         -
        pub(crate) integer: ::std::option::Option<i32>,
 2273         -
        pub(crate) long: ::std::option::Option<i64>,
 2274         -
        pub(crate) float: ::std::option::Option<f32>,
 2275         -
        pub(crate) double: ::std::option::Option<f64>,
 2276         -
        pub(crate) timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
 2277         -
        pub(crate) r#enum:
 2278         -
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 2279         -
        pub(crate) required_blob: ::std::option::Option<::aws_smithy_types::Blob>,
 2280         -
        pub(crate) required_boolean: ::std::option::Option<bool>,
 2281         -
        pub(crate) required_string: ::std::option::Option<::std::string::String>,
 2282         -
        pub(crate) required_byte: ::std::option::Option<i8>,
 2283         -
        pub(crate) required_short: ::std::option::Option<i16>,
 2284         -
        pub(crate) required_integer: ::std::option::Option<i32>,
 2285         -
        pub(crate) required_long: ::std::option::Option<i64>,
 2286         -
        pub(crate) required_float: ::std::option::Option<f32>,
 2287         -
        pub(crate) required_double: ::std::option::Option<f64>,
 2288         -
        pub(crate) required_timestamp: ::std::option::Option<::aws_smithy_types::DateTime>,
 2289         -
        pub(crate) required_enum:
 2290         -
            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 2291         -
    }
 2292         -
    impl Builder {
 2293         -
        #[allow(missing_docs)] // documentation missing in model
 2294         -
        pub fn blob(mut self, input: ::std::option::Option<::aws_smithy_types::Blob>) -> Self {
 2295         -
            self.blob = input;
 2296         -
            self
 2297         -
        }
 2298         -
        #[allow(missing_docs)] // documentation missing in model
 2299         -
        pub(crate) fn set_blob(
 2300         -
            mut self,
 2301         -
            input: Option<impl ::std::convert::Into<::aws_smithy_types::Blob>>,
 2302         -
        ) -> Self {
 2303         -
            self.blob = input.map(|v| v.into());
 2304         -
            self
 2305         -
        }
 2306         -
        #[allow(missing_docs)] // documentation missing in model
 2307         -
        pub fn boolean(mut self, input: ::std::option::Option<bool>) -> Self {
 2308         -
            self.boolean = input;
 2309         -
            self
 2310         -
        }
 2311         -
        #[allow(missing_docs)] // documentation missing in model
 2312         -
        pub(crate) fn set_boolean(
 2313         -
            mut self,
 2314         -
            input: Option<impl ::std::convert::Into<bool>>,
 2315         -
        ) -> Self {
 2316         -
            self.boolean = input.map(|v| v.into());
 2317         -
            self
 2318         -
        }
 2319         -
        #[allow(missing_docs)] // documentation missing in model
 2320         -
        pub fn string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
 2321         -
            self.string = input;
 2322         -
            self
 2323         -
        }
 2324         -
        #[allow(missing_docs)] // documentation missing in model
 2325         -
        pub(crate) fn set_string(
 2326         -
            mut self,
 2327         -
            input: Option<impl ::std::convert::Into<::std::string::String>>,
 2328         -
        ) -> Self {
 2329         -
            self.string = input.map(|v| v.into());
 2330         -
            self
 2331         -
        }
 2332         -
        #[allow(missing_docs)] // documentation missing in model
 2333         -
        pub fn byte(mut self, input: ::std::option::Option<i8>) -> Self {
 2334         -
            self.byte = input;
 2335         -
            self
 2336         -
        }
 2337         -
        #[allow(missing_docs)] // documentation missing in model
 2338         -
        pub(crate) fn set_byte(mut self, input: Option<impl ::std::convert::Into<i8>>) -> Self {
 2339         -
            self.byte = input.map(|v| v.into());
 2340         -
            self
 2341         -
        }
 2342         -
        #[allow(missing_docs)] // documentation missing in model
 2343         -
        pub fn short(mut self, input: ::std::option::Option<i16>) -> Self {
 2344         -
            self.short = input;
 2345         -
            self
 2346         -
        }
 2347         -
        #[allow(missing_docs)] // documentation missing in model
 2348         -
        pub(crate) fn set_short(mut self, input: Option<impl ::std::convert::Into<i16>>) -> Self {
 2349         -
            self.short = input.map(|v| v.into());
 2350         -
            self
 2351         -
        }
 2352         -
        #[allow(missing_docs)] // documentation missing in model
 2353         -
        pub fn integer(mut self, input: ::std::option::Option<i32>) -> Self {
 2354         -
            self.integer = input;
 2355         -
            self
 2356         -
        }
 2357         -
        #[allow(missing_docs)] // documentation missing in model
 2358         -
        pub(crate) fn set_integer(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
 2359         -
            self.integer = input.map(|v| v.into());
 2360         -
            self
 2361         -
        }
 2362         -
        #[allow(missing_docs)] // documentation missing in model
 2363         -
        pub fn long(mut self, input: ::std::option::Option<i64>) -> Self {
 2364         -
            self.long = input;
 2365         -
            self
 2366         -
        }
 2367         -
        #[allow(missing_docs)] // documentation missing in model
 2368         -
        pub(crate) fn set_long(mut self, input: Option<impl ::std::convert::Into<i64>>) -> Self {
 2369         -
            self.long = input.map(|v| v.into());
 2370         -
            self
 2371         -
        }
 2372         -
        #[allow(missing_docs)] // documentation missing in model
 2373         -
        pub fn float(mut self, input: ::std::option::Option<f32>) -> Self {
 2374         -
            self.float = input;
 2375         -
            self
 2376         -
        }
 2377         -
        #[allow(missing_docs)] // documentation missing in model
 2378         -
        pub(crate) fn set_float(mut self, input: Option<impl ::std::convert::Into<f32>>) -> Self {
 2379         -
            self.float = input.map(|v| v.into());
 2380         -
            self
 2381         -
        }
 2382         -
        #[allow(missing_docs)] // documentation missing in model
 2383         -
        pub fn double(mut self, input: ::std::option::Option<f64>) -> Self {
 2384         -
            self.double = input;
 2385         -
            self
 2386         -
        }
 2387         -
        #[allow(missing_docs)] // documentation missing in model
 2388         -
        pub(crate) fn set_double(mut self, input: Option<impl ::std::convert::Into<f64>>) -> Self {
 2389         -
            self.double = input.map(|v| v.into());
 2390         -
            self
 2391         -
        }
 2392         -
        #[allow(missing_docs)] // documentation missing in model
 2393         -
        pub fn timestamp(
 2394         -
            mut self,
 2395         -
            input: ::std::option::Option<::aws_smithy_types::DateTime>,
 2396         -
        ) -> Self {
 2397         -
            self.timestamp = input;
 2398         -
            self
 2399         -
        }
 2400         -
        #[allow(missing_docs)] // documentation missing in model
 2401         -
        pub(crate) fn set_timestamp(
 2402         -
            mut self,
 2403         -
            input: Option<impl ::std::convert::Into<::aws_smithy_types::DateTime>>,
 2404         -
        ) -> Self {
 2405         -
            self.timestamp = input.map(|v| v.into());
 2406         -
            self
 2407         -
        }
 2408         -
        #[allow(missing_docs)] // documentation missing in model
 2409         -
        pub fn r#enum(mut self, input: ::std::option::Option<crate::model::Suit>) -> Self {
 2410         -
            self.r#enum = input.map(crate::constrained::MaybeConstrained::Constrained);
 2411         -
            self
 2412         -
        }
 2413         -
        #[allow(missing_docs)] // documentation missing in model
 2414         -
        pub(crate) fn set_enum(
 2415         -
            mut self,
 2416         -
            input: Option<
 2417         -
                impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
 2418         -
            >,
 2419         -
        ) -> Self {
 2420         -
            self.r#enum = input.map(|v| v.into());
 2421         -
            self
 2422         -
        }
 2423         -
        #[allow(missing_docs)] // documentation missing in model
 2424         -
        pub fn required_blob(mut self, input: ::aws_smithy_types::Blob) -> Self {
 2425         -
            self.required_blob = Some(input);
 2426         -
            self
 2427         -
        }
 2428         -
        #[allow(missing_docs)] // documentation missing in model
 2429         -
        pub(crate) fn set_required_blob(
 2430         -
            mut self,
 2431         -
            input: impl ::std::convert::Into<::aws_smithy_types::Blob>,
 2432         -
        ) -> Self {
 2433         -
            self.required_blob = Some(input.into());
 2434         -
            self
 2435         -
        }
 2436         -
        #[allow(missing_docs)] // documentation missing in model
 2437         -
        pub fn required_boolean(mut self, input: bool) -> Self {
 2438         -
            self.required_boolean = Some(input);
 2439         -
            self
 2440         -
        }
 2441         -
        #[allow(missing_docs)] // documentation missing in model
 2442         -
        pub(crate) fn set_required_boolean(
 2443         -
            mut self,
 2444         -
            input: impl ::std::convert::Into<bool>,
 2445         -
        ) -> Self {
 2446         -
            self.required_boolean = Some(input.into());
 2447         -
            self
 2448         -
        }
 2449         -
        #[allow(missing_docs)] // documentation missing in model
 2450         -
        pub fn required_string(mut self, input: ::std::string::String) -> Self {
 2451         -
            self.required_string = Some(input);
 2452         -
            self
 2453         -
        }
 2454         -
        #[allow(missing_docs)] // documentation missing in model
 2455         -
        pub(crate) fn set_required_string(
 2456         -
            mut self,
 2457         -
            input: impl ::std::convert::Into<::std::string::String>,
 2458         -
        ) -> Self {
 2459         -
            self.required_string = Some(input.into());
 2460         -
            self
 2461         -
        }
 2462         -
        #[allow(missing_docs)] // documentation missing in model
 2463         -
        pub fn required_byte(mut self, input: i8) -> Self {
 2464         -
            self.required_byte = Some(input);
 2465         -
            self
 2466         -
        }
 2467         -
        #[allow(missing_docs)] // documentation missing in model
 2468         -
        pub(crate) fn set_required_byte(mut self, input: impl ::std::convert::Into<i8>) -> Self {
 2469         -
            self.required_byte = Some(input.into());
 2470         -
            self
 2471         -
        }
 2472         -
        #[allow(missing_docs)] // documentation missing in model
 2473         -
        pub fn required_short(mut self, input: i16) -> Self {
 2474         -
            self.required_short = Some(input);
 2475         -
            self
 2476         -
        }
 2477         -
        #[allow(missing_docs)] // documentation missing in model
 2478         -
        pub(crate) fn set_required_short(mut self, input: impl ::std::convert::Into<i16>) -> Self {
 2479         -
            self.required_short = Some(input.into());
 2480         -
            self
 2481         -
        }
        2430  +
    }
        2431  +
    /// A builder for [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
        2432  +
    #[derive(::std::default::Default, ::std::fmt::Debug)]
        2433  +
    pub struct Builder {
        2434  +
        pub(crate) events: ::std::option::Option<
        2435  +
            crate::sigv4_event_stream::SigV4Receiver<
        2436  +
                crate::model::Events,
        2437  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2438  +
            >,
        2439  +
        >,
        2440  +
    }
        2441  +
    impl Builder {
 2482   2442   
        #[allow(missing_docs)] // documentation missing in model
 2483         -
        pub fn required_integer(mut self, input: i32) -> Self {
 2484         -
            self.required_integer = Some(input);
        2443  +
        pub fn events(
        2444  +
            mut self,
        2445  +
            input: crate::sigv4_event_stream::SigV4Receiver<
        2446  +
                crate::model::Events,
        2447  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2448  +
            >,
        2449  +
        ) -> Self {
        2450  +
            self.events = Some(input);
 2485   2451   
            self
 2486   2452   
        }
 2487   2453   
        #[allow(missing_docs)] // documentation missing in model
 2488         -
        pub(crate) fn set_required_integer(
        2454  +
        pub(crate) fn set_events(
 2489   2455   
            mut self,
 2490         -
            input: impl ::std::convert::Into<i32>,
        2456  +
            input: impl ::std::convert::Into<
        2457  +
                crate::sigv4_event_stream::SigV4Receiver<
        2458  +
                    crate::model::Events,
        2459  +
                    ::aws_smithy_http::event_stream::MessageStreamError,
        2460  +
                >,
        2461  +
            >,
 2491   2462   
        ) -> Self {
 2492         -
            self.required_integer = Some(input.into());
        2463  +
            self.events = Some(input.into());
 2493   2464   
            self
 2494   2465   
        }
 2495         -
        #[allow(missing_docs)] // documentation missing in model
 2496         -
        pub fn required_long(mut self, input: i64) -> Self {
 2497         -
            self.required_long = Some(input);
 2498         -
            self
        2466  +
        /// Consumes the builder and constructs a [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput).
        2467  +
        ///
        2468  +
        /// The builder fails to construct a [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput) if a [`ConstraintViolation`] occurs.
        2469  +
        ///
        2470  +
        pub fn build(
        2471  +
            self,
        2472  +
        ) -> Result<crate::input::StreamingOperationWithInitialResponseInput, ConstraintViolation>
        2473  +
        {
        2474  +
            self.build_enforcing_all_constraints()
 2499   2475   
        }
 2500         -
        #[allow(missing_docs)] // documentation missing in model
 2501         -
        pub(crate) fn set_required_long(mut self, input: impl ::std::convert::Into<i64>) -> Self {
 2502         -
            self.required_long = Some(input.into());
 2503         -
            self
        2476  +
        fn build_enforcing_all_constraints(
        2477  +
            self,
        2478  +
        ) -> Result<crate::input::StreamingOperationWithInitialResponseInput, ConstraintViolation>
        2479  +
        {
        2480  +
            Ok(crate::input::StreamingOperationWithInitialResponseInput {
        2481  +
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
        2482  +
            })
 2504   2483   
        }
 2505         -
        #[allow(missing_docs)] // documentation missing in model
 2506         -
        pub fn required_float(mut self, input: f32) -> Self {
 2507         -
            self.required_float = Some(input);
 2508         -
            self
        2484  +
    }
        2485  +
}
        2486  +
/// See [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
        2487  +
pub mod streaming_operation_with_optional_data_input {
        2488  +
        2489  +
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
        2490  +
    /// Holds one variant for each of the ways the builder can fail.
        2491  +
    #[non_exhaustive]
        2492  +
    #[allow(clippy::enum_variant_names)]
        2493  +
    pub enum ConstraintViolation {
        2494  +
        /// `events` was not provided but it is required when building `StreamingOperationWithOptionalDataInput`.
        2495  +
        MissingEvents,
        2496  +
    }
        2497  +
    impl ::std::fmt::Display for ConstraintViolation {
        2498  +
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        2499  +
            match self {
        2500  +
                ConstraintViolation::MissingEvents => write!(f, "`events` was not provided but it is required when building `StreamingOperationWithOptionalDataInput`"),
        2501  +
            }
 2509   2502   
        }
 2510         -
        #[allow(missing_docs)] // documentation missing in model
 2511         -
        pub(crate) fn set_required_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
 2512         -
            self.required_float = Some(input.into());
 2513         -
            self
        2503  +
    }
        2504  +
    impl ::std::error::Error for ConstraintViolation {}
        2505  +
    impl ConstraintViolation {
        2506  +
        pub(crate) fn as_validation_exception_field(
        2507  +
            self,
        2508  +
            path: ::std::string::String,
        2509  +
        ) -> crate::model::ValidationExceptionField {
        2510  +
            match self {
        2511  +
            ConstraintViolation::MissingEvents => crate::model::ValidationExceptionField {
        2512  +
                                                message: format!("Value at '{}/events' failed to satisfy constraint: Member must not be null", path),
        2513  +
                                                path: path + "/events",
        2514  +
                                            },
 2514   2515   
        }
 2515         -
        #[allow(missing_docs)] // documentation missing in model
 2516         -
        pub fn required_double(mut self, input: f64) -> Self {
 2517         -
            self.required_double = Some(input);
 2518         -
            self
 2519   2516   
        }
 2520         -
        #[allow(missing_docs)] // documentation missing in model
 2521         -
        pub(crate) fn set_required_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
 2522         -
            self.required_double = Some(input.into());
 2523         -
            self
        2517  +
    }
        2518  +
    impl ::std::convert::From<ConstraintViolation>
        2519  +
        for ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection
        2520  +
    {
        2521  +
        fn from(constraint_violation: ConstraintViolation) -> Self {
        2522  +
            let first_validation_exception_field =
        2523  +
                constraint_violation.as_validation_exception_field("".to_owned());
        2524  +
            let validation_exception = crate::error::ValidationException {
        2525  +
                message: format!(
        2526  +
                    "1 validation error detected. {}",
        2527  +
                    &first_validation_exception_field.message
        2528  +
                ),
        2529  +
                field_list: Some(vec![first_validation_exception_field]),
        2530  +
            };
        2531  +
            Self::ConstraintViolation(
        2532  +
                                crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
        2533  +
                                    .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
        2534  +
                            )
        2535  +
        }
        2536  +
    }
        2537  +
    impl ::std::convert::From<Builder>
        2538  +
        for crate::constrained::MaybeConstrained<
        2539  +
            crate::input::StreamingOperationWithOptionalDataInput,
        2540  +
        >
        2541  +
    {
        2542  +
        fn from(builder: Builder) -> Self {
        2543  +
            Self::Unconstrained(builder)
        2544  +
        }
        2545  +
    }
        2546  +
    impl ::std::convert::TryFrom<Builder> for crate::input::StreamingOperationWithOptionalDataInput {
        2547  +
        type Error = ConstraintViolation;
        2548  +
        2549  +
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
        2550  +
            builder.build()
 2524   2551   
        }
        2552  +
    }
        2553  +
    /// A builder for [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
        2554  +
    #[derive(::std::default::Default, ::std::fmt::Debug)]
        2555  +
    pub struct Builder {
        2556  +
        pub(crate) optional_data: ::std::option::Option<::std::string::String>,
        2557  +
        pub(crate) events: ::std::option::Option<
        2558  +
            crate::sigv4_event_stream::SigV4Receiver<
        2559  +
                crate::model::Events,
        2560  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2561  +
            >,
        2562  +
        >,
        2563  +
    }
        2564  +
    impl Builder {
 2525   2565   
        #[allow(missing_docs)] // documentation missing in model
 2526         -
        pub fn required_timestamp(mut self, input: ::aws_smithy_types::DateTime) -> Self {
 2527         -
            self.required_timestamp = Some(input);
        2566  +
        pub fn optional_data(
        2567  +
            mut self,
        2568  +
            input: ::std::option::Option<::std::string::String>,
        2569  +
        ) -> Self {
        2570  +
            self.optional_data = input;
 2528   2571   
            self
 2529   2572   
        }
 2530   2573   
        #[allow(missing_docs)] // documentation missing in model
 2531         -
        pub(crate) fn set_required_timestamp(
        2574  +
        pub(crate) fn set_optional_data(
 2532   2575   
            mut self,
 2533         -
            input: impl ::std::convert::Into<::aws_smithy_types::DateTime>,
        2576  +
            input: Option<impl ::std::convert::Into<::std::string::String>>,
 2534   2577   
        ) -> Self {
 2535         -
            self.required_timestamp = Some(input.into());
        2578  +
            self.optional_data = input.map(|v| v.into());
 2536   2579   
            self
 2537   2580   
        }
 2538   2581   
        #[allow(missing_docs)] // documentation missing in model
 2539         -
        pub fn required_enum(mut self, input: crate::model::Suit) -> Self {
 2540         -
            self.required_enum = Some(crate::constrained::MaybeConstrained::Constrained(input));
        2582  +
        pub fn events(
        2583  +
            mut self,
        2584  +
            input: crate::sigv4_event_stream::SigV4Receiver<
        2585  +
                crate::model::Events,
        2586  +
                ::aws_smithy_http::event_stream::MessageStreamError,
        2587  +
            >,
        2588  +
        ) -> Self {
        2589  +
            self.events = Some(input);
 2541   2590   
            self
 2542   2591   
        }
 2543   2592   
        #[allow(missing_docs)] // documentation missing in model
 2544         -
        pub(crate) fn set_required_enum(
        2593  +
        pub(crate) fn set_events(
 2545   2594   
            mut self,
 2546         -
            input: impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Suit>>,
        2595  +
            input: impl ::std::convert::Into<
        2596  +
                crate::sigv4_event_stream::SigV4Receiver<
        2597  +
                    crate::model::Events,
        2598  +
                    ::aws_smithy_http::event_stream::MessageStreamError,
        2599  +
                >,
        2600  +
            >,
 2547   2601   
        ) -> Self {
 2548         -
            self.required_enum = Some(input.into());
        2602  +
            self.events = Some(input.into());
 2549   2603   
            self
 2550   2604   
        }
 2551         -
        /// Consumes the builder and constructs a [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput).
        2605  +
        /// Consumes the builder and constructs a [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput).
 2552   2606   
        ///
 2553         -
        /// The builder fails to construct a [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput) if a [`ConstraintViolation`] occurs.
        2607  +
        /// The builder fails to construct a [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput) if a [`ConstraintViolation`] occurs.
 2554   2608   
        ///
 2555         -
        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
 2556   2609   
        pub fn build(
 2557   2610   
            self,
 2558         -
        ) -> Result<crate::input::SimpleStructOperationInput, ConstraintViolation> {
        2611  +
        ) -> Result<crate::input::StreamingOperationWithOptionalDataInput, ConstraintViolation>
        2612  +
        {
 2559   2613   
            self.build_enforcing_all_constraints()
 2560   2614   
        }
 2561   2615   
        fn build_enforcing_all_constraints(
 2562   2616   
            self,
 2563         -
        ) -> Result<crate::input::SimpleStructOperationInput, ConstraintViolation> {
 2564         -
            Ok(crate::input::SimpleStructOperationInput {
 2565         -
                blob: self.blob,
 2566         -
                boolean: self.boolean,
 2567         -
                string: self.string,
 2568         -
                byte: self.byte,
 2569         -
                short: self.short,
 2570         -
                integer: self.integer,
 2571         -
                long: self.long,
 2572         -
                float: self.float,
 2573         -
                double: self.double,
 2574         -
                timestamp: self.timestamp,
 2575         -
                r#enum: self
 2576         -
                    .r#enum
 2577         -
                    .map(|v| match v {
 2578         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 2579         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 2580         -
                    })
 2581         -
                    .map(|res| res.map_err(ConstraintViolation::Enum))
 2582         -
                    .transpose()?,
 2583         -
                required_blob: self
 2584         -
                    .required_blob
 2585         -
                    .ok_or(ConstraintViolation::MissingRequiredBlob)?,
 2586         -
                required_boolean: self
 2587         -
                    .required_boolean
 2588         -
                    .ok_or(ConstraintViolation::MissingRequiredBoolean)?,
 2589         -
                required_string: self
 2590         -
                    .required_string
 2591         -
                    .ok_or(ConstraintViolation::MissingRequiredString)?,
 2592         -
                required_byte: self
 2593         -
                    .required_byte
 2594         -
                    .ok_or(ConstraintViolation::MissingRequiredByte)?,
 2595         -
                required_short: self
 2596         -
                    .required_short
 2597         -
                    .ok_or(ConstraintViolation::MissingRequiredShort)?,
 2598         -
                required_integer: self
 2599         -
                    .required_integer
 2600         -
                    .ok_or(ConstraintViolation::MissingRequiredInteger)?,
 2601         -
                required_long: self
 2602         -
                    .required_long
 2603         -
                    .ok_or(ConstraintViolation::MissingRequiredLong)?,
 2604         -
                required_float: self
 2605         -
                    .required_float
 2606         -
                    .ok_or(ConstraintViolation::MissingRequiredFloat)?,
 2607         -
                required_double: self
 2608         -
                    .required_double
 2609         -
                    .ok_or(ConstraintViolation::MissingRequiredDouble)?,
 2610         -
                required_timestamp: self
 2611         -
                    .required_timestamp
 2612         -
                    .ok_or(ConstraintViolation::MissingRequiredTimestamp)?,
 2613         -
                required_enum: self
 2614         -
                    .required_enum
 2615         -
                    .map(|v| match v {
 2616         -
                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
 2617         -
                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
 2618         -
                    })
 2619         -
                    .map(|res| res.map_err(ConstraintViolation::RequiredEnum))
 2620         -
                    .transpose()?
 2621         -
                    .ok_or(ConstraintViolation::MissingRequiredEnum)?,
        2617  +
        ) -> Result<crate::input::StreamingOperationWithOptionalDataInput, ConstraintViolation>
        2618  +
        {
        2619  +
            Ok(crate::input::StreamingOperationWithOptionalDataInput {
        2620  +
                optional_data: self.optional_data,
        2621  +
                events: self.events.ok_or(ConstraintViolation::MissingEvents)?,
 2622   2622   
            })
 2623   2623   
        }
 2624   2624   
    }
 2625   2625   
}