AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_baseline_ebs_bandwidth_mbps.rs

@@ -4,4 +131,142 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "BaselineEbsBandwidthMbps",
   26     26   
);
   27     27   
static BASELINEEBSBANDWIDTHMBPS_MEMBER_MIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#BaselineEbsBandwidthMbps$Min",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "BaselineEbsBandwidthMbps",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Integer,
   34         -
    "min",
          34  +
    "Min",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("min");
   38     38   
static BASELINEEBSBANDWIDTHMBPS_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#BaselineEbsBandwidthMbps$Max",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "BaselineEbsBandwidthMbps",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::Integer,
   45         -
    "max",
          45  +
    "Max",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("max");
   49     49   
static BASELINEEBSBANDWIDTHMBPS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    BASELINEEBSBANDWIDTHMBPS_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[&BASELINEEBSBANDWIDTHMBPS_MEMBER_MIN, &BASELINEEBSBANDWIDTHMBPS_MEMBER_MAX],
   53     53   
);
   54     54   
impl BaselineEbsBandwidthMbps {
   55     55   
    /// The schema for this shape.
   56     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BASELINEEBSBANDWIDTHMBPS_SCHEMA;
   57     57   
}
   58     58   
impl ::aws_smithy_schema::serde::SerializableStruct for BaselineEbsBandwidthMbps {
   59     59   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   60     60   
    fn serialize_members(
   61     61   
        &self,
   62     62   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   63     63   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   64     64   
        if let Some(ref val) = self.min {
   65     65   
            ser.write_integer(&BASELINEEBSBANDWIDTHMBPS_MEMBER_MIN, *val)?;
   66     66   
        }
   67     67   
        if let Some(ref val) = self.max {
   68     68   
            ser.write_integer(&BASELINEEBSBANDWIDTHMBPS_MEMBER_MAX, *val)?;
   69     69   
        }
   70     70   
        Ok(())
   71     71   
    }
   72     72   
}
   73     73   
impl BaselineEbsBandwidthMbps {
   74     74   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   75         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   76         -
        deserializer: &mut D,
          75  +
    pub fn deserialize(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   77     77   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   78     78   
        #[allow(unused_variables, unused_mut)]
   79     79   
        let mut builder = Self::builder();
   80     80   
        #[allow(
   81     81   
            unused_variables,
   82     82   
            unreachable_code,
   83     83   
            clippy::single_match,
   84     84   
            clippy::match_single_binding,
   85     85   
            clippy::diverging_sub_expression
   86     86   
        )]
   87         -
        deserializer.read_struct(&BASELINEEBSBANDWIDTHMBPS_SCHEMA, (), |_, member, deser| {
          87  +
        deserializer.read_struct(&BASELINEEBSBANDWIDTHMBPS_SCHEMA, &mut |member, deser| {
   88     88   
            match member.member_index() {
   89     89   
                Some(0) => {
   90     90   
                    builder.min = Some(deser.read_integer(member)?);
   91     91   
                }
   92     92   
                Some(1) => {
   93     93   
                    builder.max = Some(deser.read_integer(member)?);
   94     94   
                }
   95     95   
                _ => {}
   96     96   
            }
   97     97   
            Ok(())
   98     98   
        })?;
   99     99   
        Ok(builder.build())
  100    100   
    }
  101    101   
}
         102  +
impl BaselineEbsBandwidthMbps {
         103  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         104  +
    pub fn deserialize_with_response(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         106  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         107  +
        _status: u16,
         108  +
        _body: &[u8],
         109  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         110  +
        Self::deserialize(deserializer)
         111  +
    }
         112  +
}
  102    113   
impl BaselineEbsBandwidthMbps {
  103    114   
    /// Creates a new builder-style object to manufacture [`BaselineEbsBandwidthMbps`](crate::types::BaselineEbsBandwidthMbps).
  104    115   
    pub fn builder() -> crate::types::builders::BaselineEbsBandwidthMbpsBuilder {
  105    116   
        crate::types::builders::BaselineEbsBandwidthMbpsBuilder::default()
  106    117   
    }
  107    118   
}
  108    119   
  109    120   
/// A builder for [`BaselineEbsBandwidthMbps`](crate::types::BaselineEbsBandwidthMbps).
  110    121   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    122   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_baseline_ebs_bandwidth_mbps_request.rs

@@ -4,4 +129,140 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "BaselineEbsBandwidthMbpsRequest",
   26     26   
);
   27     27   
static BASELINEEBSBANDWIDTHMBPSREQUEST_MEMBER_MIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#BaselineEbsBandwidthMbpsRequest$Min",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "BaselineEbsBandwidthMbpsRequest",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Integer,
   34         -
    "min",
          34  +
    "Min",
   35     35   
    0,
   36     36   
);
   37     37   
static BASELINEEBSBANDWIDTHMBPSREQUEST_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.ec2#BaselineEbsBandwidthMbpsRequest$Max",
   40     40   
        "com.amazonaws.ec2",
   41     41   
        "BaselineEbsBandwidthMbpsRequest",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Integer,
   44         -
    "max",
          44  +
    "Max",
   45     45   
    1,
   46     46   
);
   47     47   
static BASELINEEBSBANDWIDTHMBPSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    BASELINEEBSBANDWIDTHMBPSREQUEST_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&BASELINEEBSBANDWIDTHMBPSREQUEST_MEMBER_MIN, &BASELINEEBSBANDWIDTHMBPSREQUEST_MEMBER_MAX],
   51     51   
);
   52     52   
impl BaselineEbsBandwidthMbpsRequest {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BASELINEEBSBANDWIDTHMBPSREQUEST_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for BaselineEbsBandwidthMbpsRequest {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.min {
   63     63   
            ser.write_integer(&BASELINEEBSBANDWIDTHMBPSREQUEST_MEMBER_MIN, *val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.max {
   66     66   
            ser.write_integer(&BASELINEEBSBANDWIDTHMBPSREQUEST_MEMBER_MAX, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl BaselineEbsBandwidthMbpsRequest {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&BASELINEEBSBANDWIDTHMBPSREQUEST_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&BASELINEEBSBANDWIDTHMBPSREQUEST_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.min = Some(deser.read_integer(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.max = Some(deser.read_integer(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl BaselineEbsBandwidthMbpsRequest {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  100    111   
impl BaselineEbsBandwidthMbpsRequest {
  101    112   
    /// Creates a new builder-style object to manufacture [`BaselineEbsBandwidthMbpsRequest`](crate::types::BaselineEbsBandwidthMbpsRequest).
  102    113   
    pub fn builder() -> crate::types::builders::BaselineEbsBandwidthMbpsRequestBuilder {
  103    114   
        crate::types::builders::BaselineEbsBandwidthMbpsRequestBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`BaselineEbsBandwidthMbpsRequest`](crate::types::BaselineEbsBandwidthMbpsRequest).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_baseline_performance_factors.rs

@@ -1,1 +109,120 @@
   19     19   
    "com.amazonaws.ec2",
   20     20   
    "BaselinePerformanceFactors",
   21     21   
);
   22     22   
static BASELINEPERFORMANCEFACTORS_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.ec2#BaselinePerformanceFactors$Cpu",
   25     25   
        "com.amazonaws.ec2",
   26     26   
        "BaselinePerformanceFactors",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "cpu",
          29  +
    "Cpu",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("cpu");
   33     33   
static BASELINEPERFORMANCEFACTORS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     34   
    BASELINEPERFORMANCEFACTORS_SCHEMA_ID,
   35     35   
    ::aws_smithy_schema::ShapeType::Structure,
   36     36   
    &[&BASELINEPERFORMANCEFACTORS_MEMBER_CPU],
   37     37   
);
   38     38   
impl BaselinePerformanceFactors {
   39     39   
    /// The schema for this shape.
   40     40   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BASELINEPERFORMANCEFACTORS_SCHEMA;
   41     41   
}
   42     42   
impl ::aws_smithy_schema::serde::SerializableStruct for BaselinePerformanceFactors {
   43     43   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     44   
    fn serialize_members(
   45     45   
        &self,
   46     46   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     47   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     48   
        if let Some(ref val) = self.cpu {
   49     49   
            ser.write_struct(&BASELINEPERFORMANCEFACTORS_MEMBER_CPU, val)?;
   50     50   
        }
   51     51   
        Ok(())
   52     52   
    }
   53     53   
}
   54     54   
impl BaselinePerformanceFactors {
   55     55   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   56         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   57         -
        deserializer: &mut D,
          56  +
    pub fn deserialize(
          57  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   58     58   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        #[allow(unused_variables, unused_mut)]
   60     60   
        let mut builder = Self::builder();
   61     61   
        #[allow(
   62     62   
            unused_variables,
   63     63   
            unreachable_code,
   64     64   
            clippy::single_match,
   65     65   
            clippy::match_single_binding,
   66     66   
            clippy::diverging_sub_expression
   67     67   
        )]
   68         -
        deserializer.read_struct(&BASELINEPERFORMANCEFACTORS_SCHEMA, (), |_, member, deser| {
          68  +
        deserializer.read_struct(&BASELINEPERFORMANCEFACTORS_SCHEMA, &mut |member, deser| {
   69     69   
            match member.member_index() {
   70     70   
                Some(0) => {
   71     71   
                    builder.cpu = Some(crate::types::CpuPerformanceFactor::deserialize(deser)?);
   72     72   
                }
   73     73   
                _ => {}
   74     74   
            }
   75     75   
            Ok(())
   76     76   
        })?;
   77     77   
        Ok(builder.build())
   78     78   
    }
   79     79   
}
          80  +
impl BaselinePerformanceFactors {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          82  +
    pub fn deserialize_with_response(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   80     91   
impl BaselinePerformanceFactors {
   81     92   
    /// Creates a new builder-style object to manufacture [`BaselinePerformanceFactors`](crate::types::BaselinePerformanceFactors).
   82     93   
    pub fn builder() -> crate::types::builders::BaselinePerformanceFactorsBuilder {
   83     94   
        crate::types::builders::BaselinePerformanceFactorsBuilder::default()
   84     95   
    }
   85     96   
}
   86     97   
   87     98   
/// A builder for [`BaselinePerformanceFactors`](crate::types::BaselinePerformanceFactors).
   88     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   89    100   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_baseline_performance_factors_request.rs

@@ -1,1 +108,119 @@
   19     19   
    "com.amazonaws.ec2",
   20     20   
    "BaselinePerformanceFactorsRequest",
   21     21   
);
   22     22   
static BASELINEPERFORMANCEFACTORSREQUEST_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.ec2#BaselinePerformanceFactorsRequest$Cpu",
   25     25   
        "com.amazonaws.ec2",
   26     26   
        "BaselinePerformanceFactorsRequest",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "cpu",
          29  +
    "Cpu",
   30     30   
    0,
   31     31   
);
   32     32   
static BASELINEPERFORMANCEFACTORSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    BASELINEPERFORMANCEFACTORSREQUEST_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&BASELINEPERFORMANCEFACTORSREQUEST_MEMBER_CPU],
   36     36   
);
   37     37   
impl BaselinePerformanceFactorsRequest {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BASELINEPERFORMANCEFACTORSREQUEST_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for BaselinePerformanceFactorsRequest {
   42     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     43   
    fn serialize_members(
   44     44   
        &self,
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.cpu {
   48     48   
            ser.write_struct(&BASELINEPERFORMANCEFACTORSREQUEST_MEMBER_CPU, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl BaselinePerformanceFactorsRequest {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&BASELINEPERFORMANCEFACTORSREQUEST_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&BASELINEPERFORMANCEFACTORSREQUEST_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.cpu = Some(crate::types::CpuPerformanceFactorRequest::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl BaselinePerformanceFactorsRequest {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl BaselinePerformanceFactorsRequest {
   80     91   
    /// Creates a new builder-style object to manufacture [`BaselinePerformanceFactorsRequest`](crate::types::BaselinePerformanceFactorsRequest).
   81     92   
    pub fn builder() -> crate::types::builders::BaselinePerformanceFactorsRequestBuilder {
   82     93   
        crate::types::builders::BaselinePerformanceFactorsRequestBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`BaselinePerformanceFactorsRequest`](crate::types::BaselinePerformanceFactorsRequest).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_blob_attribute_value.rs

@@ -1,1 +100,111 @@
   10     10   
    #[allow(missing_docs)] // documentation missing in model
   11     11   
    pub fn value(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
   12     12   
        self.value.as_ref()
   13     13   
    }
   14     14   
}
   15     15   
static BLOBATTRIBUTEVALUE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   16     16   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BlobAttributeValue", "com.amazonaws.ec2", "BlobAttributeValue");
   17     17   
static BLOBATTRIBUTEVALUE_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   18     18   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BlobAttributeValue$Value", "com.amazonaws.ec2", "BlobAttributeValue"),
   19     19   
    ::aws_smithy_schema::ShapeType::Blob,
   20         -
    "value",
          20  +
    "Value",
   21     21   
    0,
   22     22   
)
   23     23   
.with_xml_name("value");
   24     24   
static BLOBATTRIBUTEVALUE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    BLOBATTRIBUTEVALUE_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&BLOBATTRIBUTEVALUE_MEMBER_VALUE],
   28     28   
);
   29     29   
impl BlobAttributeValue {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BLOBATTRIBUTEVALUE_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for BlobAttributeValue {
   34     34   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   35     35   
    fn serialize_members(
   36     36   
        &self,
   37     37   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   38     38   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   39     39   
        if let Some(ref val) = self.value {
   40     40   
            ser.write_blob(&BLOBATTRIBUTEVALUE_MEMBER_VALUE, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl BlobAttributeValue {
   46     46   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   47         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   48         -
        deserializer: &mut D,
          47  +
    pub fn deserialize(
          48  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   49     49   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   50     50   
        #[allow(unused_variables, unused_mut)]
   51     51   
        let mut builder = Self::builder();
   52     52   
        #[allow(
   53     53   
            unused_variables,
   54     54   
            unreachable_code,
   55     55   
            clippy::single_match,
   56     56   
            clippy::match_single_binding,
   57     57   
            clippy::diverging_sub_expression
   58     58   
        )]
   59         -
        deserializer.read_struct(&BLOBATTRIBUTEVALUE_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&BLOBATTRIBUTEVALUE_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.value = Some(deser.read_blob(member)?);
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl BlobAttributeValue {
          72  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          73  +
    pub fn deserialize_with_response(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          75  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          76  +
        _status: u16,
          77  +
        _body: &[u8],
          78  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          79  +
        Self::deserialize(deserializer)
          80  +
    }
          81  +
}
   71     82   
impl BlobAttributeValue {
   72     83   
    /// Creates a new builder-style object to manufacture [`BlobAttributeValue`](crate::types::BlobAttributeValue).
   73     84   
    pub fn builder() -> crate::types::builders::BlobAttributeValueBuilder {
   74     85   
        crate::types::builders::BlobAttributeValueBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`BlobAttributeValue`](crate::types::BlobAttributeValue).
   79     90   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   80     91   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_block_device_mapping.rs

@@ -13,13 +175,186 @@
   33     33   
    /// <p>Constraints: For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.</p>
   34     34   
    pub fn virtual_name(&self) -> ::std::option::Option<&str> {
   35     35   
        self.virtual_name.as_deref()
   36     36   
    }
   37     37   
}
   38     38   
static BLOCKDEVICEMAPPING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BlockDeviceMapping", "com.amazonaws.ec2", "BlockDeviceMapping");
   40     40   
static BLOCKDEVICEMAPPING_MEMBER_EBS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BlockDeviceMapping$Ebs", "com.amazonaws.ec2", "BlockDeviceMapping"),
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43         -
    "ebs",
          43  +
    "Ebs",
   44     44   
    0,
   45     45   
)
   46     46   
.with_xml_name("ebs");
   47     47   
static BLOCKDEVICEMAPPING_MEMBER_NO_DEVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BlockDeviceMapping$NoDevice", "com.amazonaws.ec2", "BlockDeviceMapping"),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "no_device",
          50  +
    "NoDevice",
   51     51   
    1,
   52     52   
)
   53     53   
.with_xml_name("noDevice");
   54     54   
static BLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.ec2#BlockDeviceMapping$DeviceName",
   57     57   
        "com.amazonaws.ec2",
   58     58   
        "BlockDeviceMapping",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "device_name",
          61  +
    "DeviceName",
   62     62   
    2,
   63     63   
)
   64     64   
.with_xml_name("deviceName");
   65     65   
static BLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.ec2#BlockDeviceMapping$VirtualName",
   68     68   
        "com.amazonaws.ec2",
   69     69   
        "BlockDeviceMapping",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "virtual_name",
          72  +
    "VirtualName",
   73     73   
    3,
   74     74   
)
   75     75   
.with_xml_name("virtualName");
   76     76   
static BLOCKDEVICEMAPPING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   77     77   
    BLOCKDEVICEMAPPING_SCHEMA_ID,
   78     78   
    ::aws_smithy_schema::ShapeType::Structure,
   79     79   
    &[
   80     80   
        &BLOCKDEVICEMAPPING_MEMBER_EBS,
   81     81   
        &BLOCKDEVICEMAPPING_MEMBER_NO_DEVICE,
   82     82   
        &BLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME,
   83     83   
        &BLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME,
   84     84   
    ],
   85     85   
);
   86     86   
impl BlockDeviceMapping {
   87     87   
    /// The schema for this shape.
   88     88   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BLOCKDEVICEMAPPING_SCHEMA;
   89     89   
}
   90     90   
impl ::aws_smithy_schema::serde::SerializableStruct for BlockDeviceMapping {
   91     91   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   92     92   
    fn serialize_members(
   93     93   
        &self,
   94     94   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   95     95   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   96     96   
        if let Some(ref val) = self.ebs {
   97     97   
            ser.write_struct(&BLOCKDEVICEMAPPING_MEMBER_EBS, val)?;
   98     98   
        }
   99     99   
        if let Some(ref val) = self.no_device {
  100    100   
            ser.write_string(&BLOCKDEVICEMAPPING_MEMBER_NO_DEVICE, val)?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.device_name {
  103    103   
            ser.write_string(&BLOCKDEVICEMAPPING_MEMBER_DEVICE_NAME, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.virtual_name {
  106    106   
            ser.write_string(&BLOCKDEVICEMAPPING_MEMBER_VIRTUAL_NAME, val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl BlockDeviceMapping {
  112    112   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  113         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  114         -
        deserializer: &mut D,
         113  +
    pub fn deserialize(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  115    115   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        #[allow(unused_variables, unused_mut)]
  117    117   
        let mut builder = Self::builder();
  118    118   
        #[allow(
  119    119   
            unused_variables,
  120    120   
            unreachable_code,
  121    121   
            clippy::single_match,
  122    122   
            clippy::match_single_binding,
  123    123   
            clippy::diverging_sub_expression
  124    124   
        )]
  125         -
        deserializer.read_struct(&BLOCKDEVICEMAPPING_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&BLOCKDEVICEMAPPING_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128    128   
                    builder.ebs = Some(crate::types::EbsBlockDevice::deserialize(deser)?);
  129    129   
                }
  130    130   
                Some(1) => {
  131    131   
                    builder.no_device = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(2) => {
  134    134   
                    builder.device_name = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(3) => {
  137    137   
                    builder.virtual_name = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                _ => {}
  140    140   
            }
  141    141   
            Ok(())
  142    142   
        })?;
  143    143   
        Ok(builder.build())
  144    144   
    }
  145    145   
}
         146  +
impl BlockDeviceMapping {
         147  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         148  +
    pub fn deserialize_with_response(
         149  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         150  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         151  +
        _status: u16,
         152  +
        _body: &[u8],
         153  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         154  +
        Self::deserialize(deserializer)
         155  +
    }
         156  +
}
  146    157   
impl BlockDeviceMapping {
  147    158   
    /// Creates a new builder-style object to manufacture [`BlockDeviceMapping`](crate::types::BlockDeviceMapping).
  148    159   
    pub fn builder() -> crate::types::builders::BlockDeviceMappingBuilder {
  149    160   
        crate::types::builders::BlockDeviceMappingBuilder::default()
  150    161   
    }
  151    162   
}
  152    163   
  153    164   
/// A builder for [`BlockDeviceMapping`](crate::types::BlockDeviceMapping).
  154    165   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  155    166   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_block_device_mapping_response.rs

@@ -16,16 +182,193 @@
   36     36   
    "com.amazonaws.ec2",
   37     37   
    "BlockDeviceMappingResponse",
   38     38   
);
   39     39   
static BLOCKDEVICEMAPPINGRESPONSE_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2#BlockDeviceMappingResponse$DeviceName",
   42     42   
        "com.amazonaws.ec2",
   43     43   
        "BlockDeviceMappingResponse",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "device_name",
          46  +
    "DeviceName",
   47     47   
    0,
   48     48   
)
   49     49   
.with_xml_name("deviceName");
   50     50   
static BLOCKDEVICEMAPPINGRESPONSE_MEMBER_VIRTUAL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.ec2#BlockDeviceMappingResponse$VirtualName",
   53     53   
        "com.amazonaws.ec2",
   54     54   
        "BlockDeviceMappingResponse",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "virtual_name",
          57  +
    "VirtualName",
   58     58   
    1,
   59     59   
)
   60     60   
.with_xml_name("virtualName");
   61     61   
static BLOCKDEVICEMAPPINGRESPONSE_MEMBER_EBS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2#BlockDeviceMappingResponse$Ebs",
   64     64   
        "com.amazonaws.ec2",
   65     65   
        "BlockDeviceMappingResponse",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68         -
    "ebs",
          68  +
    "Ebs",
   69     69   
    2,
   70     70   
)
   71     71   
.with_xml_name("ebs");
   72     72   
static BLOCKDEVICEMAPPINGRESPONSE_MEMBER_NO_DEVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.ec2#BlockDeviceMappingResponse$NoDevice",
   75     75   
        "com.amazonaws.ec2",
   76     76   
        "BlockDeviceMappingResponse",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "no_device",
          79  +
    "NoDevice",
   80     80   
    3,
   81     81   
)
   82     82   
.with_xml_name("noDevice");
   83     83   
static BLOCKDEVICEMAPPINGRESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    BLOCKDEVICEMAPPINGRESPONSE_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &BLOCKDEVICEMAPPINGRESPONSE_MEMBER_DEVICE_NAME,
   88     88   
        &BLOCKDEVICEMAPPINGRESPONSE_MEMBER_VIRTUAL_NAME,
   89     89   
        &BLOCKDEVICEMAPPINGRESPONSE_MEMBER_EBS,
   90     90   
        &BLOCKDEVICEMAPPINGRESPONSE_MEMBER_NO_DEVICE,
   91     91   
    ],
   92     92   
);
   93     93   
impl BlockDeviceMappingResponse {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BLOCKDEVICEMAPPINGRESPONSE_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for BlockDeviceMappingResponse {
   98     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99     99   
    fn serialize_members(
  100    100   
        &self,
  101    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        if let Some(ref val) = self.device_name {
  104    104   
            ser.write_string(&BLOCKDEVICEMAPPINGRESPONSE_MEMBER_DEVICE_NAME, val)?;
  105    105   
        }
  106    106   
        if let Some(ref val) = self.virtual_name {
  107    107   
            ser.write_string(&BLOCKDEVICEMAPPINGRESPONSE_MEMBER_VIRTUAL_NAME, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.ebs {
  110    110   
            ser.write_struct(&BLOCKDEVICEMAPPINGRESPONSE_MEMBER_EBS, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.no_device {
  113    113   
            ser.write_string(&BLOCKDEVICEMAPPINGRESPONSE_MEMBER_NO_DEVICE, val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl BlockDeviceMappingResponse {
  119    119   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         120  +
    pub fn deserialize(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    122   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        #[allow(unused_variables, unused_mut)]
  124    124   
        let mut builder = Self::builder();
  125    125   
        #[allow(
  126    126   
            unused_variables,
  127    127   
            unreachable_code,
  128    128   
            clippy::single_match,
  129    129   
            clippy::match_single_binding,
  130    130   
            clippy::diverging_sub_expression
  131    131   
        )]
  132         -
        deserializer.read_struct(&BLOCKDEVICEMAPPINGRESPONSE_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&BLOCKDEVICEMAPPINGRESPONSE_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.device_name = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.virtual_name = Some(deser.read_string(member)?);
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.ebs = Some(crate::types::EbsBlockDeviceResponse::deserialize(deser)?);
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.no_device = Some(deser.read_string(member)?);
  145    145   
                }
  146    146   
                _ => {}
  147    147   
            }
  148    148   
            Ok(())
  149    149   
        })?;
  150    150   
        Ok(builder.build())
  151    151   
    }
  152    152   
}
         153  +
impl BlockDeviceMappingResponse {
         154  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         155  +
    pub fn deserialize_with_response(
         156  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         157  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         158  +
        _status: u16,
         159  +
        _body: &[u8],
         160  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         161  +
        Self::deserialize(deserializer)
         162  +
    }
         163  +
}
  153    164   
impl BlockDeviceMappingResponse {
  154    165   
    /// Creates a new builder-style object to manufacture [`BlockDeviceMappingResponse`](crate::types::BlockDeviceMappingResponse).
  155    166   
    pub fn builder() -> crate::types::builders::BlockDeviceMappingResponseBuilder {
  156    167   
        crate::types::builders::BlockDeviceMappingResponseBuilder::default()
  157    168   
    }
  158    169   
}
  159    170   
  160    171   
/// A builder for [`BlockDeviceMappingResponse`](crate::types::BlockDeviceMappingResponse).
  161    172   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  162    173   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_block_public_access_states.rs

@@ -14,14 +124,135 @@
   34     34   
    "com.amazonaws.ec2",
   35     35   
    "BlockPublicAccessStates",
   36     36   
);
   37     37   
static BLOCKPUBLICACCESSSTATES_MEMBER_INTERNET_GATEWAY_BLOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.ec2#BlockPublicAccessStates$InternetGatewayBlockMode",
   40     40   
        "com.amazonaws.ec2",
   41     41   
        "BlockPublicAccessStates",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "internet_gateway_block_mode",
          44  +
    "InternetGatewayBlockMode",
   45     45   
    0,
   46     46   
)
   47     47   
.with_xml_name("internetGatewayBlockMode");
   48     48   
static BLOCKPUBLICACCESSSTATES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    BLOCKPUBLICACCESSSTATES_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&BLOCKPUBLICACCESSSTATES_MEMBER_INTERNET_GATEWAY_BLOCK_MODE],
   52     52   
);
   53     53   
impl BlockPublicAccessStates {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BLOCKPUBLICACCESSSTATES_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for BlockPublicAccessStates {
   58     58   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     59   
    fn serialize_members(
   60     60   
        &self,
   61     61   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     62   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     63   
        if let Some(ref val) = self.internet_gateway_block_mode {
   64     64   
            ser.write_string(&BLOCKPUBLICACCESSSTATES_MEMBER_INTERNET_GATEWAY_BLOCK_MODE, val.as_str())?;
   65     65   
        }
   66     66   
        Ok(())
   67     67   
    }
   68     68   
}
   69     69   
impl BlockPublicAccessStates {
   70     70   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   71         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   72         -
        deserializer: &mut D,
          71  +
    pub fn deserialize(
          72  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   73     73   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   74     74   
        #[allow(unused_variables, unused_mut)]
   75     75   
        let mut builder = Self::builder();
   76     76   
        #[allow(
   77     77   
            unused_variables,
   78     78   
            unreachable_code,
   79     79   
            clippy::single_match,
   80     80   
            clippy::match_single_binding,
   81     81   
            clippy::diverging_sub_expression
   82     82   
        )]
   83         -
        deserializer.read_struct(&BLOCKPUBLICACCESSSTATES_SCHEMA, (), |_, member, deser| {
          83  +
        deserializer.read_struct(&BLOCKPUBLICACCESSSTATES_SCHEMA, &mut |member, deser| {
   84     84   
            match member.member_index() {
   85     85   
                Some(0) => {
   86     86   
                    builder.internet_gateway_block_mode = Some(crate::types::BlockPublicAccessMode::from(deser.read_string(member)?.as_str()));
   87     87   
                }
   88     88   
                _ => {}
   89     89   
            }
   90     90   
            Ok(())
   91     91   
        })?;
   92     92   
        Ok(builder.build())
   93     93   
    }
   94     94   
}
          95  +
impl BlockPublicAccessStates {
          96  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          97  +
    pub fn deserialize_with_response(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          99  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         100  +
        _status: u16,
         101  +
        _body: &[u8],
         102  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         103  +
        Self::deserialize(deserializer)
         104  +
    }
         105  +
}
   95    106   
impl BlockPublicAccessStates {
   96    107   
    /// Creates a new builder-style object to manufacture [`BlockPublicAccessStates`](crate::types::BlockPublicAccessStates).
   97    108   
    pub fn builder() -> crate::types::builders::BlockPublicAccessStatesBuilder {
   98    109   
        crate::types::builders::BlockPublicAccessStatesBuilder::default()
   99    110   
    }
  100    111   
}
  101    112   
  102    113   
/// A builder for [`BlockPublicAccessStates`](crate::types::BlockPublicAccessStates).
  103    114   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  104    115   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_bundle_task.rs

@@ -33,33 +243,254 @@
   53     53   
    /// <p>If the task fails, a description of the error.</p>
   54     54   
    pub fn bundle_task_error(&self) -> ::std::option::Option<&crate::types::BundleTaskError> {
   55     55   
        self.bundle_task_error.as_ref()
   56     56   
    }
   57     57   
}
   58     58   
static BUNDLETASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask", "com.amazonaws.ec2", "BundleTask");
   60     60   
static BUNDLETASK_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$InstanceId", "com.amazonaws.ec2", "BundleTask"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "instance_id",
          63  +
    "InstanceId",
   64     64   
    0,
   65     65   
)
   66     66   
.with_xml_name("instanceId");
   67     67   
static BUNDLETASK_MEMBER_BUNDLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$BundleId", "com.amazonaws.ec2", "BundleTask"),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "bundle_id",
          70  +
    "BundleId",
   71     71   
    1,
   72     72   
)
   73     73   
.with_xml_name("bundleId");
   74     74   
static BUNDLETASK_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$State", "com.amazonaws.ec2", "BundleTask"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "state",
          77  +
    "State",
   78     78   
    2,
   79     79   
)
   80     80   
.with_xml_name("state");
   81     81   
static BUNDLETASK_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$StartTime", "com.amazonaws.ec2", "BundleTask"),
   83     83   
    ::aws_smithy_schema::ShapeType::Timestamp,
   84         -
    "start_time",
          84  +
    "StartTime",
   85     85   
    3,
   86     86   
)
   87     87   
.with_xml_name("startTime");
   88     88   
static BUNDLETASK_MEMBER_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$UpdateTime", "com.amazonaws.ec2", "BundleTask"),
   90     90   
    ::aws_smithy_schema::ShapeType::Timestamp,
   91         -
    "update_time",
          91  +
    "UpdateTime",
   92     92   
    4,
   93     93   
)
   94     94   
.with_xml_name("updateTime");
   95     95   
static BUNDLETASK_MEMBER_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$Storage", "com.amazonaws.ec2", "BundleTask"),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "storage",
          98  +
    "Storage",
   99     99   
    5,
  100    100   
)
  101    101   
.with_xml_name("storage");
  102    102   
static BUNDLETASK_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$Progress", "com.amazonaws.ec2", "BundleTask"),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "progress",
         105  +
    "Progress",
  106    106   
    6,
  107    107   
)
  108    108   
.with_xml_name("progress");
  109    109   
static BUNDLETASK_MEMBER_BUNDLE_TASK_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTask$BundleTaskError", "com.amazonaws.ec2", "BundleTask"),
  111    111   
    ::aws_smithy_schema::ShapeType::Structure,
  112         -
    "bundle_task_error",
         112  +
    "BundleTaskError",
  113    113   
    7,
  114    114   
)
  115    115   
.with_xml_name("error");
  116    116   
static BUNDLETASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  117    117   
    BUNDLETASK_SCHEMA_ID,
  118    118   
    ::aws_smithy_schema::ShapeType::Structure,
  119    119   
    &[
  120    120   
        &BUNDLETASK_MEMBER_INSTANCE_ID,
  121    121   
        &BUNDLETASK_MEMBER_BUNDLE_ID,
  122    122   
        &BUNDLETASK_MEMBER_STATE,
  123    123   
        &BUNDLETASK_MEMBER_START_TIME,
  124    124   
        &BUNDLETASK_MEMBER_UPDATE_TIME,
  125    125   
        &BUNDLETASK_MEMBER_STORAGE,
  126    126   
        &BUNDLETASK_MEMBER_PROGRESS,
  127    127   
        &BUNDLETASK_MEMBER_BUNDLE_TASK_ERROR,
  128    128   
    ],
  129    129   
);
  130    130   
impl BundleTask {
  131    131   
    /// The schema for this shape.
  132    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BUNDLETASK_SCHEMA;
  133    133   
}
  134    134   
impl ::aws_smithy_schema::serde::SerializableStruct for BundleTask {
  135    135   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  136    136   
    fn serialize_members(
  137    137   
        &self,
  138    138   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  139    139   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  140    140   
        if let Some(ref val) = self.instance_id {
  141    141   
            ser.write_string(&BUNDLETASK_MEMBER_INSTANCE_ID, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.bundle_id {
  144    144   
            ser.write_string(&BUNDLETASK_MEMBER_BUNDLE_ID, val)?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.state {
  147    147   
            ser.write_string(&BUNDLETASK_MEMBER_STATE, val.as_str())?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.start_time {
  150    150   
            ser.write_timestamp(&BUNDLETASK_MEMBER_START_TIME, val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.update_time {
  153    153   
            ser.write_timestamp(&BUNDLETASK_MEMBER_UPDATE_TIME, val)?;
  154    154   
        }
  155    155   
        if let Some(ref val) = self.storage {
  156    156   
            ser.write_struct(&BUNDLETASK_MEMBER_STORAGE, val)?;
  157    157   
        }
  158    158   
        if let Some(ref val) = self.progress {
  159    159   
            ser.write_string(&BUNDLETASK_MEMBER_PROGRESS, val)?;
  160    160   
        }
  161    161   
        if let Some(ref val) = self.bundle_task_error {
  162    162   
            ser.write_struct(&BUNDLETASK_MEMBER_BUNDLE_TASK_ERROR, val)?;
  163    163   
        }
  164    164   
        Ok(())
  165    165   
    }
  166    166   
}
  167    167   
impl BundleTask {
  168    168   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  169         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  170         -
        deserializer: &mut D,
         169  +
    pub fn deserialize(
         170  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  171    171   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  172    172   
        #[allow(unused_variables, unused_mut)]
  173    173   
        let mut builder = Self::builder();
  174    174   
        #[allow(
  175    175   
            unused_variables,
  176    176   
            unreachable_code,
  177    177   
            clippy::single_match,
  178    178   
            clippy::match_single_binding,
  179    179   
            clippy::diverging_sub_expression
  180    180   
        )]
  181         -
        deserializer.read_struct(&BUNDLETASK_SCHEMA, (), |_, member, deser| {
         181  +
        deserializer.read_struct(&BUNDLETASK_SCHEMA, &mut |member, deser| {
  182    182   
            match member.member_index() {
  183    183   
                Some(0) => {
  184    184   
                    builder.instance_id = Some(deser.read_string(member)?);
  185    185   
                }
  186    186   
                Some(1) => {
  187    187   
                    builder.bundle_id = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(2) => {
  190    190   
                    builder.state = Some(crate::types::BundleTaskState::from(deser.read_string(member)?.as_str()));
  191    191   
                }
  192    192   
                Some(3) => {
  193    193   
                    builder.start_time = Some(deser.read_timestamp(member)?);
  194    194   
                }
  195    195   
                Some(4) => {
  196    196   
                    builder.update_time = Some(deser.read_timestamp(member)?);
  197    197   
                }
  198    198   
                Some(5) => {
  199    199   
                    builder.storage = Some(crate::types::Storage::deserialize(deser)?);
  200    200   
                }
  201    201   
                Some(6) => {
  202    202   
                    builder.progress = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(7) => {
  205    205   
                    builder.bundle_task_error = Some(crate::types::BundleTaskError::deserialize(deser)?);
  206    206   
                }
  207    207   
                _ => {}
  208    208   
            }
  209    209   
            Ok(())
  210    210   
        })?;
  211    211   
        Ok(builder.build())
  212    212   
    }
  213    213   
}
         214  +
impl BundleTask {
         215  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         216  +
    pub fn deserialize_with_response(
         217  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         218  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         219  +
        _status: u16,
         220  +
        _body: &[u8],
         221  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         222  +
        Self::deserialize(deserializer)
         223  +
    }
         224  +
}
  214    225   
impl BundleTask {
  215    226   
    /// Creates a new builder-style object to manufacture [`BundleTask`](crate::types::BundleTask).
  216    227   
    pub fn builder() -> crate::types::builders::BundleTaskBuilder {
  217    228   
        crate::types::builders::BundleTaskBuilder::default()
  218    229   
    }
  219    230   
}
  220    231   
  221    232   
/// A builder for [`BundleTask`](crate::types::BundleTask).
  222    233   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  223    234   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_bundle_task_error.rs

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The error message.</p>
   18     18   
    pub fn message(&self) -> ::std::option::Option<&str> {
   19     19   
        self.message.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static BUNDLETASKERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTaskError", "com.amazonaws.ec2", "BundleTaskError");
   24     24   
static BUNDLETASKERROR_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTaskError$Code", "com.amazonaws.ec2", "BundleTaskError"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "code",
          27  +
    "Code",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("code");
   31     31   
static BUNDLETASKERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#BundleTaskError$Message", "com.amazonaws.ec2", "BundleTaskError"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "message",
          34  +
    "Message",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("message");
   38     38   
static BUNDLETASKERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    BUNDLETASKERROR_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&BUNDLETASKERROR_MEMBER_CODE, &BUNDLETASKERROR_MEMBER_MESSAGE],
   42     42   
);
   43     43   
impl BundleTaskError {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BUNDLETASKERROR_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for BundleTaskError {
   48     48   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   49     49   
    fn serialize_members(
   50     50   
        &self,
   51     51   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   52     52   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        if let Some(ref val) = self.code {
   54     54   
            ser.write_string(&BUNDLETASKERROR_MEMBER_CODE, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.message {
   57     57   
            ser.write_string(&BUNDLETASKERROR_MEMBER_MESSAGE, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl BundleTaskError {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&BUNDLETASKERROR_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&BUNDLETASKERROR_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.code = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.message = Some(deser.read_string(member)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl BundleTaskError {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl BundleTaskError {
   92    103   
    /// Creates a new builder-style object to manufacture [`BundleTaskError`](crate::types::BundleTaskError).
   93    104   
    pub fn builder() -> crate::types::builders::BundleTaskErrorBuilder {
   94    105   
        crate::types::builders::BundleTaskErrorBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`BundleTaskError`](crate::types::BundleTaskError).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_byoasn.rs

@@ -9,9 +163,174 @@
   29     29   
    /// <p>The provisioning state of the BYOASN.</p>
   30     30   
    pub fn state(&self) -> ::std::option::Option<&crate::types::AsnState> {
   31     31   
        self.state.as_ref()
   32     32   
    }
   33     33   
}
   34     34   
static BYOASN_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Byoasn", "com.amazonaws.ec2", "Byoasn");
   36     36   
static BYOASN_MEMBER_ASN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Byoasn$Asn", "com.amazonaws.ec2", "Byoasn"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "asn",
          39  +
    "Asn",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("asn");
   43     43   
static BYOASN_MEMBER_IPAM_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Byoasn$IpamId", "com.amazonaws.ec2", "Byoasn"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "ipam_id",
          46  +
    "IpamId",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("ipamId");
   50     50   
static BYOASN_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Byoasn$StatusMessage", "com.amazonaws.ec2", "Byoasn"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "status_message",
          53  +
    "StatusMessage",
   54     54   
    2,
   55     55   
)
   56     56   
.with_xml_name("statusMessage");
   57     57   
static BYOASN_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Byoasn$State", "com.amazonaws.ec2", "Byoasn"),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "state",
          60  +
    "State",
   61     61   
    3,
   62     62   
)
   63     63   
.with_xml_name("state");
   64     64   
static BYOASN_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    BYOASN_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &BYOASN_MEMBER_ASN,
   69     69   
        &BYOASN_MEMBER_IPAM_ID,
   70     70   
        &BYOASN_MEMBER_STATUS_MESSAGE,
   71     71   
        &BYOASN_MEMBER_STATE,
   72     72   
    ],
   73     73   
);
   74     74   
impl Byoasn {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BYOASN_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for Byoasn {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.asn {
   85     85   
            ser.write_string(&BYOASN_MEMBER_ASN, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.ipam_id {
   88     88   
            ser.write_string(&BYOASN_MEMBER_IPAM_ID, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.status_message {
   91     91   
            ser.write_string(&BYOASN_MEMBER_STATUS_MESSAGE, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.state {
   94     94   
            ser.write_string(&BYOASN_MEMBER_STATE, val.as_str())?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl Byoasn {
  100    100   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  101         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  102         -
        deserializer: &mut D,
         101  +
    pub fn deserialize(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  103    103   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        #[allow(unused_variables, unused_mut)]
  105    105   
        let mut builder = Self::builder();
  106    106   
        #[allow(
  107    107   
            unused_variables,
  108    108   
            unreachable_code,
  109    109   
            clippy::single_match,
  110    110   
            clippy::match_single_binding,
  111    111   
            clippy::diverging_sub_expression
  112    112   
        )]
  113         -
        deserializer.read_struct(&BYOASN_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&BYOASN_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.asn = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.ipam_id = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.status_message = Some(deser.read_string(member)?);
  123    123   
                }
  124    124   
                Some(3) => {
  125    125   
                    builder.state = Some(crate::types::AsnState::from(deser.read_string(member)?.as_str()));
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl Byoasn {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
  134    145   
impl Byoasn {
  135    146   
    /// Creates a new builder-style object to manufacture [`Byoasn`](crate::types::Byoasn).
  136    147   
    pub fn builder() -> crate::types::builders::ByoasnBuilder {
  137    148   
        crate::types::builders::ByoasnBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`Byoasn`](crate::types::Byoasn).
  142    153   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    154   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_byoip_cidr.rs

@@ -81,81 +281,289 @@
  101    101   
    /// </note>
  102    102   
    pub fn network_border_group(&self) -> ::std::option::Option<&str> {
  103    103   
        self.network_border_group.as_deref()
  104    104   
    }
  105    105   
}
  106    106   
static BYOIPCIDR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  107    107   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr", "com.amazonaws.ec2", "ByoipCidr");
  108    108   
static BYOIPCIDR_MEMBER_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr$Cidr", "com.amazonaws.ec2", "ByoipCidr"),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "cidr",
         111  +
    "Cidr",
  112    112   
    0,
  113    113   
)
  114    114   
.with_xml_name("cidr");
  115    115   
static BYOIPCIDR_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr$Description", "com.amazonaws.ec2", "ByoipCidr"),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "description",
         118  +
    "Description",
  119    119   
    1,
  120    120   
)
  121    121   
.with_xml_name("description");
  122    122   
static BYOIPCIDR_MEMBER_ASN_ASSOCIATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr$AsnAssociations", "com.amazonaws.ec2", "ByoipCidr"),
  124    124   
    ::aws_smithy_schema::ShapeType::List,
  125         -
    "asn_associations",
         125  +
    "AsnAssociations",
  126    126   
    2,
  127    127   
)
  128    128   
.with_xml_name("asnAssociationSet");
  129    129   
static BYOIPCIDR_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr$StatusMessage", "com.amazonaws.ec2", "ByoipCidr"),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "status_message",
         132  +
    "StatusMessage",
  133    133   
    3,
  134    134   
)
  135    135   
.with_xml_name("statusMessage");
  136    136   
static BYOIPCIDR_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr$State", "com.amazonaws.ec2", "ByoipCidr"),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "state",
         139  +
    "State",
  140    140   
    4,
  141    141   
)
  142    142   
.with_xml_name("state");
  143    143   
static BYOIPCIDR_MEMBER_NETWORK_BORDER_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ByoipCidr$NetworkBorderGroup", "com.amazonaws.ec2", "ByoipCidr"),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "network_border_group",
         146  +
    "NetworkBorderGroup",
  147    147   
    5,
  148    148   
)
  149    149   
.with_xml_name("networkBorderGroup");
  150    150   
static BYOIPCIDR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  151    151   
    BYOIPCIDR_SCHEMA_ID,
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153    153   
    &[
  154    154   
        &BYOIPCIDR_MEMBER_CIDR,
  155    155   
        &BYOIPCIDR_MEMBER_DESCRIPTION,
  156    156   
        &BYOIPCIDR_MEMBER_ASN_ASSOCIATIONS,
  157    157   
        &BYOIPCIDR_MEMBER_STATUS_MESSAGE,
  158    158   
        &BYOIPCIDR_MEMBER_STATE,
  159    159   
        &BYOIPCIDR_MEMBER_NETWORK_BORDER_GROUP,
  160    160   
    ],
  161    161   
);
  162    162   
impl ByoipCidr {
  163    163   
    /// The schema for this shape.
  164    164   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BYOIPCIDR_SCHEMA;
  165    165   
}
  166    166   
impl ::aws_smithy_schema::serde::SerializableStruct for ByoipCidr {
  167    167   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  168    168   
    fn serialize_members(
  169    169   
        &self,
  170    170   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  171    171   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  172    172   
        if let Some(ref val) = self.cidr {
  173    173   
            ser.write_string(&BYOIPCIDR_MEMBER_CIDR, val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.description {
  176    176   
            ser.write_string(&BYOIPCIDR_MEMBER_DESCRIPTION, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.asn_associations {
  179    179   
            ser.write_list(
  180    180   
                &BYOIPCIDR_MEMBER_ASN_ASSOCIATIONS,
  181    181   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  182    182   
                    for item in val {
  183    183   
                        ser.write_struct(crate::types::AsnAssociation::SCHEMA, item)?;
  184    184   
                    }
  185    185   
                    Ok(())
  186    186   
                },
  187    187   
            )?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.status_message {
  190    190   
            ser.write_string(&BYOIPCIDR_MEMBER_STATUS_MESSAGE, val)?;
  191    191   
        }
  192    192   
        if let Some(ref val) = self.state {
  193    193   
            ser.write_string(&BYOIPCIDR_MEMBER_STATE, val.as_str())?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.network_border_group {
  196    196   
            ser.write_string(&BYOIPCIDR_MEMBER_NETWORK_BORDER_GROUP, val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl ByoipCidr {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&BYOIPCIDR_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&BYOIPCIDR_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.cidr = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.description = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(2) => {
  224    224   
                    builder.asn_associations = Some({
  225         -
                        let container = if let Some(cap) = deser.container_size() {
  226         -
                            Vec::with_capacity(cap)
  227         -
                        } else {
  228         -
                            Vec::new()
  229         -
                        };
  230         -
                        deser.read_list(member, container, |mut list, deser| {
  231         -
                            list.push(crate::types::AsnAssociation::deserialize(deser)?);
  232         -
                            Ok(list)
  233         -
                        })?
         225  +
                        let mut container = Vec::new();
         226  +
                        deser.read_list(member, &mut |deser| {
         227  +
                            container.push(crate::types::AsnAssociation::deserialize(deser)?);
         228  +
                            Ok(())
         229  +
                        })?;
         230  +
                        container
  234    231   
                    });
  235    232   
                }
  236    233   
                Some(3) => {
  237    234   
                    builder.status_message = Some(deser.read_string(member)?);
  238    235   
                }
  239    236   
                Some(4) => {
  240    237   
                    builder.state = Some(crate::types::ByoipCidrState::from(deser.read_string(member)?.as_str()));
  241    238   
                }
  242    239   
                Some(5) => {
  243    240   
                    builder.network_border_group = Some(deser.read_string(member)?);
  244    241   
                }
  245    242   
                _ => {}
  246    243   
            }
  247    244   
            Ok(())
  248    245   
        })?;
  249    246   
        Ok(builder.build())
  250    247   
    }
  251    248   
}
         249  +
impl ByoipCidr {
         250  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         251  +
    pub fn deserialize_with_response(
         252  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         253  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         254  +
        _status: u16,
         255  +
        _body: &[u8],
         256  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         257  +
        Self::deserialize(deserializer)
         258  +
    }
         259  +
}
  252    260   
impl ByoipCidr {
  253    261   
    /// Creates a new builder-style object to manufacture [`ByoipCidr`](crate::types::ByoipCidr).
  254    262   
    pub fn builder() -> crate::types::builders::ByoipCidrBuilder {
  255    263   
        crate::types::builders::ByoipCidrBuilder::default()
  256    264   
    }
  257    265   
}
  258    266   
  259    267   
/// A builder for [`ByoipCidr`](crate::types::ByoipCidr).
  260    268   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  261    269   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_cancel_capacity_reservation_fleet_error.rs

@@ -4,4 +134,145 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "CancelCapacityReservationFleetError",
   26     26   
);
   27     27   
static CANCELCAPACITYRESERVATIONFLEETERROR_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#CancelCapacityReservationFleetError$Code",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "CancelCapacityReservationFleetError",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "code",
          34  +
    "Code",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("code");
   38     38   
static CANCELCAPACITYRESERVATIONFLEETERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#CancelCapacityReservationFleetError$Message",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "CancelCapacityReservationFleetError",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "message",
          45  +
    "Message",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("message");
   49     49   
static CANCELCAPACITYRESERVATIONFLEETERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    CANCELCAPACITYRESERVATIONFLEETERROR_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &CANCELCAPACITYRESERVATIONFLEETERROR_MEMBER_CODE,
   54     54   
        &CANCELCAPACITYRESERVATIONFLEETERROR_MEMBER_MESSAGE,
   55     55   
    ],
   56     56   
);
   57     57   
impl CancelCapacityReservationFleetError {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELCAPACITYRESERVATIONFLEETERROR_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelCapacityReservationFleetError {
   62     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     63   
    fn serialize_members(
   64     64   
        &self,
   65     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        if let Some(ref val) = self.code {
   68     68   
            ser.write_string(&CANCELCAPACITYRESERVATIONFLEETERROR_MEMBER_CODE, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.message {
   71     71   
            ser.write_string(&CANCELCAPACITYRESERVATIONFLEETERROR_MEMBER_MESSAGE, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl CancelCapacityReservationFleetError {
   77     77   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   78         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   79         -
        deserializer: &mut D,
          78  +
    pub fn deserialize(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   80     80   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        #[allow(unused_variables, unused_mut)]
   82     82   
        let mut builder = Self::builder();
   83     83   
        #[allow(
   84     84   
            unused_variables,
   85     85   
            unreachable_code,
   86     86   
            clippy::single_match,
   87     87   
            clippy::match_single_binding,
   88     88   
            clippy::diverging_sub_expression
   89     89   
        )]
   90         -
        deserializer.read_struct(&CANCELCAPACITYRESERVATIONFLEETERROR_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&CANCELCAPACITYRESERVATIONFLEETERROR_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.code = Some(deser.read_string(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.message = Some(deser.read_string(member)?);
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl CancelCapacityReservationFleetError {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         107  +
    pub fn deserialize_with_response(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         110  +
        _status: u16,
         111  +
        _body: &[u8],
         112  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         113  +
        Self::deserialize(deserializer)
         114  +
    }
         115  +
}
  105    116   
impl CancelCapacityReservationFleetError {
  106    117   
    /// Creates a new builder-style object to manufacture [`CancelCapacityReservationFleetError`](crate::types::CancelCapacityReservationFleetError).
  107    118   
    pub fn builder() -> crate::types::builders::CancelCapacityReservationFleetErrorBuilder {
  108    119   
        crate::types::builders::CancelCapacityReservationFleetErrorBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`CancelCapacityReservationFleetError`](crate::types::CancelCapacityReservationFleetError).
  113    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  114    125   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_cancel_spot_fleet_requests_error.rs

@@ -4,4 +131,142 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "CancelSpotFleetRequestsError",
   26     26   
);
   27     27   
static CANCELSPOTFLEETREQUESTSERROR_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#CancelSpotFleetRequestsError$Code",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "CancelSpotFleetRequestsError",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "code",
          34  +
    "Code",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("code");
   38     38   
static CANCELSPOTFLEETREQUESTSERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#CancelSpotFleetRequestsError$Message",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "CancelSpotFleetRequestsError",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "message",
          45  +
    "Message",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("message");
   49     49   
static CANCELSPOTFLEETREQUESTSERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    CANCELSPOTFLEETREQUESTSERROR_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[&CANCELSPOTFLEETREQUESTSERROR_MEMBER_CODE, &CANCELSPOTFLEETREQUESTSERROR_MEMBER_MESSAGE],
   53     53   
);
   54     54   
impl CancelSpotFleetRequestsError {
   55     55   
    /// The schema for this shape.
   56     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELSPOTFLEETREQUESTSERROR_SCHEMA;
   57     57   
}
   58     58   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelSpotFleetRequestsError {
   59     59   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   60     60   
    fn serialize_members(
   61     61   
        &self,
   62     62   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   63     63   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   64     64   
        if let Some(ref val) = self.code {
   65     65   
            ser.write_string(&CANCELSPOTFLEETREQUESTSERROR_MEMBER_CODE, val.as_str())?;
   66     66   
        }
   67     67   
        if let Some(ref val) = self.message {
   68     68   
            ser.write_string(&CANCELSPOTFLEETREQUESTSERROR_MEMBER_MESSAGE, val)?;
   69     69   
        }
   70     70   
        Ok(())
   71     71   
    }
   72     72   
}
   73     73   
impl CancelSpotFleetRequestsError {
   74     74   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   75         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   76         -
        deserializer: &mut D,
          75  +
    pub fn deserialize(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   77     77   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   78     78   
        #[allow(unused_variables, unused_mut)]
   79     79   
        let mut builder = Self::builder();
   80     80   
        #[allow(
   81     81   
            unused_variables,
   82     82   
            unreachable_code,
   83     83   
            clippy::single_match,
   84     84   
            clippy::match_single_binding,
   85     85   
            clippy::diverging_sub_expression
   86     86   
        )]
   87         -
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSERROR_SCHEMA, (), |_, member, deser| {
          87  +
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSERROR_SCHEMA, &mut |member, deser| {
   88     88   
            match member.member_index() {
   89     89   
                Some(0) => {
   90     90   
                    builder.code = Some(crate::types::CancelBatchErrorCode::from(deser.read_string(member)?.as_str()));
   91     91   
                }
   92     92   
                Some(1) => {
   93     93   
                    builder.message = Some(deser.read_string(member)?);
   94     94   
                }
   95     95   
                _ => {}
   96     96   
            }
   97     97   
            Ok(())
   98     98   
        })?;
   99     99   
        Ok(builder.build())
  100    100   
    }
  101    101   
}
         102  +
impl CancelSpotFleetRequestsError {
         103  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         104  +
    pub fn deserialize_with_response(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         106  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         107  +
        _status: u16,
         108  +
        _body: &[u8],
         109  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         110  +
        Self::deserialize(deserializer)
         111  +
    }
         112  +
}
  102    113   
impl CancelSpotFleetRequestsError {
  103    114   
    /// Creates a new builder-style object to manufacture [`CancelSpotFleetRequestsError`](crate::types::CancelSpotFleetRequestsError).
  104    115   
    pub fn builder() -> crate::types::builders::CancelSpotFleetRequestsErrorBuilder {
  105    116   
        crate::types::builders::CancelSpotFleetRequestsErrorBuilder::default()
  106    117   
    }
  107    118   
}
  108    119   
  109    120   
/// A builder for [`CancelSpotFleetRequestsError`](crate::types::CancelSpotFleetRequestsError).
  110    121   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    122   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_cancel_spot_fleet_requests_error_item.rs

@@ -4,4 +134,145 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "CancelSpotFleetRequestsErrorItem",
   26     26   
);
   27     27   
static CANCELSPOTFLEETREQUESTSERRORITEM_MEMBER_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ec2#CancelSpotFleetRequestsErrorItem$Error",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "CancelSpotFleetRequestsErrorItem",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    "error",
          34  +
    "Error",
   35     35   
    0,
   36     36   
)
   37     37   
.with_xml_name("error");
   38     38   
static CANCELSPOTFLEETREQUESTSERRORITEM_MEMBER_SPOT_FLEET_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#CancelSpotFleetRequestsErrorItem$SpotFleetRequestId",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "CancelSpotFleetRequestsErrorItem",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "spot_fleet_request_id",
          45  +
    "SpotFleetRequestId",
   46     46   
    1,
   47     47   
)
   48     48   
.with_xml_name("spotFleetRequestId");
   49     49   
static CANCELSPOTFLEETREQUESTSERRORITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    CANCELSPOTFLEETREQUESTSERRORITEM_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &CANCELSPOTFLEETREQUESTSERRORITEM_MEMBER_ERROR,
   54     54   
        &CANCELSPOTFLEETREQUESTSERRORITEM_MEMBER_SPOT_FLEET_REQUEST_ID,
   55     55   
    ],
   56     56   
);
   57     57   
impl CancelSpotFleetRequestsErrorItem {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELSPOTFLEETREQUESTSERRORITEM_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelSpotFleetRequestsErrorItem {
   62     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     63   
    fn serialize_members(
   64     64   
        &self,
   65     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        if let Some(ref val) = self.error {
   68     68   
            ser.write_struct(&CANCELSPOTFLEETREQUESTSERRORITEM_MEMBER_ERROR, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.spot_fleet_request_id {
   71     71   
            ser.write_string(&CANCELSPOTFLEETREQUESTSERRORITEM_MEMBER_SPOT_FLEET_REQUEST_ID, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl CancelSpotFleetRequestsErrorItem {
   77     77   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   78         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   79         -
        deserializer: &mut D,
          78  +
    pub fn deserialize(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   80     80   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        #[allow(unused_variables, unused_mut)]
   82     82   
        let mut builder = Self::builder();
   83     83   
        #[allow(
   84     84   
            unused_variables,
   85     85   
            unreachable_code,
   86     86   
            clippy::single_match,
   87     87   
            clippy::match_single_binding,
   88     88   
            clippy::diverging_sub_expression
   89     89   
        )]
   90         -
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSERRORITEM_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSERRORITEM_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.error = Some(crate::types::CancelSpotFleetRequestsError::deserialize(deser)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.spot_fleet_request_id = Some(deser.read_string(member)?);
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl CancelSpotFleetRequestsErrorItem {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         107  +
    pub fn deserialize_with_response(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         110  +
        _status: u16,
         111  +
        _body: &[u8],
         112  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         113  +
        Self::deserialize(deserializer)
         114  +
    }
         115  +
}
  105    116   
impl CancelSpotFleetRequestsErrorItem {
  106    117   
    /// Creates a new builder-style object to manufacture [`CancelSpotFleetRequestsErrorItem`](crate::types::CancelSpotFleetRequestsErrorItem).
  107    118   
    pub fn builder() -> crate::types::builders::CancelSpotFleetRequestsErrorItemBuilder {
  108    119   
        crate::types::builders::CancelSpotFleetRequestsErrorItemBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`CancelSpotFleetRequestsErrorItem`](crate::types::CancelSpotFleetRequestsErrorItem).
  113    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  114    125   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_cancel_spot_fleet_requests_success_item.rs

@@ -11,11 +160,171 @@
   31     31   
    "CancelSpotFleetRequestsSuccessItem",
   32     32   
);
   33     33   
static CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_CURRENT_SPOT_FLEET_REQUEST_STATE: ::aws_smithy_schema::Schema =
   34     34   
    ::aws_smithy_schema::Schema::new_member(
   35     35   
        ::aws_smithy_schema::ShapeId::from_static(
   36     36   
            "com.amazonaws.ec2#CancelSpotFleetRequestsSuccessItem$CurrentSpotFleetRequestState",
   37     37   
            "com.amazonaws.ec2",
   38     38   
            "CancelSpotFleetRequestsSuccessItem",
   39     39   
        ),
   40     40   
        ::aws_smithy_schema::ShapeType::String,
   41         -
        "current_spot_fleet_request_state",
          41  +
        "CurrentSpotFleetRequestState",
   42     42   
        0,
   43     43   
    )
   44     44   
    .with_xml_name("currentSpotFleetRequestState");
   45     45   
static CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_PREVIOUS_SPOT_FLEET_REQUEST_STATE: ::aws_smithy_schema::Schema =
   46     46   
    ::aws_smithy_schema::Schema::new_member(
   47     47   
        ::aws_smithy_schema::ShapeId::from_static(
   48     48   
            "com.amazonaws.ec2#CancelSpotFleetRequestsSuccessItem$PreviousSpotFleetRequestState",
   49     49   
            "com.amazonaws.ec2",
   50     50   
            "CancelSpotFleetRequestsSuccessItem",
   51     51   
        ),
   52     52   
        ::aws_smithy_schema::ShapeType::String,
   53         -
        "previous_spot_fleet_request_state",
          53  +
        "PreviousSpotFleetRequestState",
   54     54   
        1,
   55     55   
    )
   56     56   
    .with_xml_name("previousSpotFleetRequestState");
   57     57   
static CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_SPOT_FLEET_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.ec2#CancelSpotFleetRequestsSuccessItem$SpotFleetRequestId",
   60     60   
        "com.amazonaws.ec2",
   61     61   
        "CancelSpotFleetRequestsSuccessItem",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "spot_fleet_request_id",
          64  +
    "SpotFleetRequestId",
   65     65   
    2,
   66     66   
)
   67     67   
.with_xml_name("spotFleetRequestId");
   68     68   
static CANCELSPOTFLEETREQUESTSSUCCESSITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    CANCELSPOTFLEETREQUESTSSUCCESSITEM_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_CURRENT_SPOT_FLEET_REQUEST_STATE,
   73     73   
        &CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_PREVIOUS_SPOT_FLEET_REQUEST_STATE,
   74     74   
        &CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_SPOT_FLEET_REQUEST_ID,
   75     75   
    ],
   76     76   
);
   77     77   
impl CancelSpotFleetRequestsSuccessItem {
   78     78   
    /// The schema for this shape.
   79     79   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CANCELSPOTFLEETREQUESTSSUCCESSITEM_SCHEMA;
   80     80   
}
   81     81   
impl ::aws_smithy_schema::serde::SerializableStruct for CancelSpotFleetRequestsSuccessItem {
   82     82   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   83     83   
    fn serialize_members(
   84     84   
        &self,
   85     85   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   86     86   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   87     87   
        if let Some(ref val) = self.current_spot_fleet_request_state {
   88     88   
            ser.write_string(&CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_CURRENT_SPOT_FLEET_REQUEST_STATE, val.as_str())?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.previous_spot_fleet_request_state {
   91     91   
            ser.write_string(&CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_PREVIOUS_SPOT_FLEET_REQUEST_STATE, val.as_str())?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.spot_fleet_request_id {
   94     94   
            ser.write_string(&CANCELSPOTFLEETREQUESTSSUCCESSITEM_MEMBER_SPOT_FLEET_REQUEST_ID, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl CancelSpotFleetRequestsSuccessItem {
  100    100   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  101         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  102         -
        deserializer: &mut D,
         101  +
    pub fn deserialize(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  103    103   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        #[allow(unused_variables, unused_mut)]
  105    105   
        let mut builder = Self::builder();
  106    106   
        #[allow(
  107    107   
            unused_variables,
  108    108   
            unreachable_code,
  109    109   
            clippy::single_match,
  110    110   
            clippy::match_single_binding,
  111    111   
            clippy::diverging_sub_expression
  112    112   
        )]
  113         -
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSSUCCESSITEM_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&CANCELSPOTFLEETREQUESTSSUCCESSITEM_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.current_spot_fleet_request_state = Some(crate::types::BatchState::from(deser.read_string(member)?.as_str()));
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.previous_spot_fleet_request_state = Some(crate::types::BatchState::from(deser.read_string(member)?.as_str()));
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.spot_fleet_request_id = Some(deser.read_string(member)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
  128    128   
        Ok(builder.build())
  129    129   
    }
  130    130   
}
         131  +
impl CancelSpotFleetRequestsSuccessItem {
         132  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         133  +
    pub fn deserialize_with_response(
         134  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         135  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         136  +
        _status: u16,
         137  +
        _body: &[u8],
         138  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         139  +
        Self::deserialize(deserializer)
         140  +
    }
         141  +
}
  131    142   
impl CancelSpotFleetRequestsSuccessItem {
  132    143   
    /// Creates a new builder-style object to manufacture [`CancelSpotFleetRequestsSuccessItem`](crate::types::CancelSpotFleetRequestsSuccessItem).
  133    144   
    pub fn builder() -> crate::types::builders::CancelSpotFleetRequestsSuccessItemBuilder {
  134    145   
        crate::types::builders::CancelSpotFleetRequestsSuccessItemBuilder::default()
  135    146   
    }
  136    147   
}
  137    148   
  138    149   
/// A builder for [`CancelSpotFleetRequestsSuccessItem`](crate::types::CancelSpotFleetRequestsSuccessItem).
  139    150   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  140    151   
#[non_exhaustive]