AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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

@@ -8,8 +172,177 @@
   28     28   
    "com.amazonaws.ec2",
   29     29   
    "CreateVolumePermissionModifications",
   30     30   
);
   31     31   
static CREATEVOLUMEPERMISSIONMODIFICATIONS_MEMBER_ADD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.ec2#CreateVolumePermissionModifications$Add",
   34     34   
        "com.amazonaws.ec2",
   35     35   
        "CreateVolumePermissionModifications",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::List,
   38         -
    "add",
          38  +
    "Add",
   39     39   
    0,
   40     40   
);
   41     41   
static CREATEVOLUMEPERMISSIONMODIFICATIONS_MEMBER_REMOVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.ec2#CreateVolumePermissionModifications$Remove",
   44     44   
        "com.amazonaws.ec2",
   45     45   
        "CreateVolumePermissionModifications",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::List,
   48         -
    "remove",
          48  +
    "Remove",
   49     49   
    1,
   50     50   
);
   51     51   
static CREATEVOLUMEPERMISSIONMODIFICATIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    CREATEVOLUMEPERMISSIONMODIFICATIONS_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[
   55     55   
        &CREATEVOLUMEPERMISSIONMODIFICATIONS_MEMBER_ADD,
   56     56   
        &CREATEVOLUMEPERMISSIONMODIFICATIONS_MEMBER_REMOVE,
   57     57   
    ],
   58     58   
);
   59     59   
impl CreateVolumePermissionModifications {
   60     60   
    /// The schema for this shape.
   61     61   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVOLUMEPERMISSIONMODIFICATIONS_SCHEMA;
   62     62   
}
   63     63   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVolumePermissionModifications {
   64     64   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   65     65   
    fn serialize_members(
   66     66   
        &self,
   67     67   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   68     68   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        if let Some(ref val) = self.add {
   70     70   
            ser.write_list(
   71     71   
                &CREATEVOLUMEPERMISSIONMODIFICATIONS_MEMBER_ADD,
   72     72   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     73   
                    for item in val {
   74     74   
                        ser.write_struct(crate::types::CreateVolumePermission::SCHEMA, item)?;
   75     75   
                    }
   76     76   
                    Ok(())
   77     77   
                },
   78     78   
            )?;
   79     79   
        }
   80     80   
        if let Some(ref val) = self.remove {
   81     81   
            ser.write_list(
   82     82   
                &CREATEVOLUMEPERMISSIONMODIFICATIONS_MEMBER_REMOVE,
   83     83   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   84     84   
                    for item in val {
   85     85   
                        ser.write_struct(crate::types::CreateVolumePermission::SCHEMA, item)?;
   86     86   
                    }
   87     87   
                    Ok(())
   88     88   
                },
   89     89   
            )?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl CreateVolumePermissionModifications {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&CREATEVOLUMEPERMISSIONMODIFICATIONS_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&CREATEVOLUMEPERMISSIONMODIFICATIONS_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.add = Some({
  112         -
                        let container = if let Some(cap) = deser.container_size() {
  113         -
                            Vec::with_capacity(cap)
  114         -
                        } else {
  115         -
                            Vec::new()
  116         -
                        };
  117         -
                        deser.read_list(member, container, |mut list, deser| {
  118         -
                            list.push(crate::types::CreateVolumePermission::deserialize(deser)?);
  119         -
                            Ok(list)
  120         -
                        })?
         112  +
                        let mut container = Vec::new();
         113  +
                        deser.read_list(member, &mut |deser| {
         114  +
                            container.push(crate::types::CreateVolumePermission::deserialize(deser)?);
         115  +
                            Ok(())
         116  +
                        })?;
         117  +
                        container
  121    118   
                    });
  122    119   
                }
  123    120   
                Some(1) => {
  124    121   
                    builder.remove = Some({
  125         -
                        let container = if let Some(cap) = deser.container_size() {
  126         -
                            Vec::with_capacity(cap)
  127         -
                        } else {
  128         -
                            Vec::new()
  129         -
                        };
  130         -
                        deser.read_list(member, container, |mut list, deser| {
  131         -
                            list.push(crate::types::CreateVolumePermission::deserialize(deser)?);
  132         -
                            Ok(list)
  133         -
                        })?
         122  +
                        let mut container = Vec::new();
         123  +
                        deser.read_list(member, &mut |deser| {
         124  +
                            container.push(crate::types::CreateVolumePermission::deserialize(deser)?);
         125  +
                            Ok(())
         126  +
                        })?;
         127  +
                        container
  134    128   
                    });
  135    129   
                }
  136    130   
                _ => {}
  137    131   
            }
  138    132   
            Ok(())
  139    133   
        })?;
  140    134   
        Ok(builder.build())
  141    135   
    }
  142    136   
}
         137  +
impl CreateVolumePermissionModifications {
         138  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         139  +
    pub fn deserialize_with_response(
         140  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         141  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         142  +
        _status: u16,
         143  +
        _body: &[u8],
         144  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         145  +
        Self::deserialize(deserializer)
         146  +
    }
         147  +
}
  143    148   
impl CreateVolumePermissionModifications {
  144    149   
    /// Creates a new builder-style object to manufacture [`CreateVolumePermissionModifications`](crate::types::CreateVolumePermissionModifications).
  145    150   
    pub fn builder() -> crate::types::builders::CreateVolumePermissionModificationsBuilder {
  146    151   
        crate::types::builders::CreateVolumePermissionModificationsBuilder::default()
  147    152   
    }
  148    153   
}
  149    154   
  150    155   
/// A builder for [`CreateVolumePermissionModifications`](crate::types::CreateVolumePermissionModifications).
  151    156   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  152    157   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -1,1 +109,120 @@
   20     20   
    "com.amazonaws.ec2",
   21     21   
    "CreditSpecificationRequest",
   22     22   
);
   23     23   
static CREDITSPECIFICATIONREQUEST_MEMBER_CPU_CREDITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   24     24   
    ::aws_smithy_schema::ShapeId::from_static(
   25     25   
        "com.amazonaws.ec2#CreditSpecificationRequest$CpuCredits",
   26     26   
        "com.amazonaws.ec2",
   27     27   
        "CreditSpecificationRequest",
   28     28   
    ),
   29     29   
    ::aws_smithy_schema::ShapeType::String,
   30         -
    "cpu_credits",
          30  +
    "CpuCredits",
   31     31   
    0,
   32     32   
);
   33     33   
static CREDITSPECIFICATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     34   
    CREDITSPECIFICATIONREQUEST_SCHEMA_ID,
   35     35   
    ::aws_smithy_schema::ShapeType::Structure,
   36     36   
    &[&CREDITSPECIFICATIONREQUEST_MEMBER_CPU_CREDITS],
   37     37   
);
   38     38   
impl CreditSpecificationRequest {
   39     39   
    /// The schema for this shape.
   40     40   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREDITSPECIFICATIONREQUEST_SCHEMA;
   41     41   
}
   42     42   
impl ::aws_smithy_schema::serde::SerializableStruct for CreditSpecificationRequest {
   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_credits {
   49     49   
            ser.write_string(&CREDITSPECIFICATIONREQUEST_MEMBER_CPU_CREDITS, val)?;
   50     50   
        }
   51     51   
        Ok(())
   52     52   
    }
   53     53   
}
   54     54   
impl CreditSpecificationRequest {
   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(&CREDITSPECIFICATIONREQUEST_SCHEMA, (), |_, member, deser| {
          68  +
        deserializer.read_struct(&CREDITSPECIFICATIONREQUEST_SCHEMA, &mut |member, deser| {
   69     69   
            match member.member_index() {
   70     70   
                Some(0) => {
   71     71   
                    builder.cpu_credits = Some(deser.read_string(member)?);
   72     72   
                }
   73     73   
                _ => {}
   74     74   
            }
   75     75   
            Ok(())
   76     76   
        })?;
   77     77   
        Ok(builder.build())
   78     78   
    }
   79     79   
}
          80  +
impl CreditSpecificationRequest {
          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 CreditSpecificationRequest {
   81     92   
    /// Creates a new builder-style object to manufacture [`CreditSpecificationRequest`](crate::types::CreditSpecificationRequest).
   82     93   
    pub fn builder() -> crate::types::builders::CreditSpecificationRequestBuilder {
   83     94   
        crate::types::builders::CreditSpecificationRequestBuilder::default()
   84     95   
    }
   85     96   
}
   86     97   
   87     98   
/// A builder for [`CreditSpecificationRequest`](crate::types::CreditSpecificationRequest).
   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/_customer_gateway.rs

@@ -45,45 +165,165 @@
   65     65   
    /// <p>Valid values: <code>1</code> to <code>2,147,483,647</code></p>
   66     66   
    pub fn bgp_asn(&self) -> ::std::option::Option<&str> {
   67     67   
        self.bgp_asn.as_deref()
   68     68   
    }
   69     69   
}
   70     70   
static CUSTOMERGATEWAY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway", "com.amazonaws.ec2", "CustomerGateway");
   72     72   
static CUSTOMERGATEWAY_MEMBER_CERTIFICATE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$CertificateArn", "com.amazonaws.ec2", "CustomerGateway"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "certificate_arn",
          75  +
    "CertificateArn",
   76     76   
    0,
   77     77   
)
   78     78   
.with_xml_name("certificateArn");
   79     79   
static CUSTOMERGATEWAY_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$DeviceName", "com.amazonaws.ec2", "CustomerGateway"),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "device_name",
          82  +
    "DeviceName",
   83     83   
    1,
   84     84   
)
   85     85   
.with_xml_name("deviceName");
   86     86   
static CUSTOMERGATEWAY_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$Tags", "com.amazonaws.ec2", "CustomerGateway"),
   88     88   
    ::aws_smithy_schema::ShapeType::List,
   89         -
    "tags",
          89  +
    "Tags",
   90     90   
    2,
   91     91   
)
   92     92   
.with_xml_name("tagSet");
   93     93   
static CUSTOMERGATEWAY_MEMBER_BGP_ASN_EXTENDED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$BgpAsnExtended", "com.amazonaws.ec2", "CustomerGateway"),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "bgp_asn_extended",
          96  +
    "BgpAsnExtended",
   97     97   
    3,
   98     98   
)
   99     99   
.with_xml_name("bgpAsnExtended");
  100    100   
static CUSTOMERGATEWAY_MEMBER_CUSTOMER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.ec2#CustomerGateway$CustomerGatewayId",
  103    103   
        "com.amazonaws.ec2",
  104    104   
        "CustomerGateway",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "customer_gateway_id",
         107  +
    "CustomerGatewayId",
  108    108   
    4,
  109    109   
)
  110    110   
.with_xml_name("customerGatewayId");
  111    111   
static CUSTOMERGATEWAY_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$State", "com.amazonaws.ec2", "CustomerGateway"),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "state",
         114  +
    "State",
  115    115   
    5,
  116    116   
)
  117    117   
.with_xml_name("state");
  118    118   
static CUSTOMERGATEWAY_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$Type", "com.amazonaws.ec2", "CustomerGateway"),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "r##type",
         121  +
    "Type",
  122    122   
    6,
  123    123   
)
  124    124   
.with_xml_name("type");
  125    125   
static CUSTOMERGATEWAY_MEMBER_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$IpAddress", "com.amazonaws.ec2", "CustomerGateway"),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "ip_address",
         128  +
    "IpAddress",
  129    129   
    7,
  130    130   
)
  131    131   
.with_xml_name("ipAddress");
  132    132   
static CUSTOMERGATEWAY_MEMBER_BGP_ASN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CustomerGateway$BgpAsn", "com.amazonaws.ec2", "CustomerGateway"),
  134    134   
    ::aws_smithy_schema::ShapeType::String,
  135         -
    "bgp_asn",
         135  +
    "BgpAsn",
  136    136   
    8,
  137    137   
)
  138    138   
.with_xml_name("bgpAsn");
  139    139   
static CUSTOMERGATEWAY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  140    140   
    CUSTOMERGATEWAY_SCHEMA_ID,
  141    141   
    ::aws_smithy_schema::ShapeType::Structure,
  142    142   
    &[
  143    143   
        &CUSTOMERGATEWAY_MEMBER_CERTIFICATE_ARN,
  144    144   
        &CUSTOMERGATEWAY_MEMBER_DEVICE_NAME,
  145    145   
        &CUSTOMERGATEWAY_MEMBER_TAGS,
@@ -174,174 +291,299 @@
  194    194   
            ser.write_string(&CUSTOMERGATEWAY_MEMBER_IP_ADDRESS, val)?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.bgp_asn {
  197    197   
            ser.write_string(&CUSTOMERGATEWAY_MEMBER_BGP_ASN, val)?;
  198    198   
        }
  199    199   
        Ok(())
  200    200   
    }
  201    201   
}
  202    202   
impl CustomerGateway {
  203    203   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  204         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  205         -
        deserializer: &mut D,
         204  +
    pub fn deserialize(
         205  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  206    206   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  207    207   
        #[allow(unused_variables, unused_mut)]
  208    208   
        let mut builder = Self::builder();
  209    209   
        #[allow(
  210    210   
            unused_variables,
  211    211   
            unreachable_code,
  212    212   
            clippy::single_match,
  213    213   
            clippy::match_single_binding,
  214    214   
            clippy::diverging_sub_expression
  215    215   
        )]
  216         -
        deserializer.read_struct(&CUSTOMERGATEWAY_SCHEMA, (), |_, member, deser| {
         216  +
        deserializer.read_struct(&CUSTOMERGATEWAY_SCHEMA, &mut |member, deser| {
  217    217   
            match member.member_index() {
  218    218   
                Some(0) => {
  219    219   
                    builder.certificate_arn = Some(deser.read_string(member)?);
  220    220   
                }
  221    221   
                Some(1) => {
  222    222   
                    builder.device_name = Some(deser.read_string(member)?);
  223    223   
                }
  224    224   
                Some(2) => {
  225    225   
                    builder.tags = Some({
  226         -
                        let container = if let Some(cap) = deser.container_size() {
  227         -
                            Vec::with_capacity(cap)
  228         -
                        } else {
  229         -
                            Vec::new()
  230         -
                        };
  231         -
                        deser.read_list(member, container, |mut list, deser| {
  232         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  233         -
                            Ok(list)
  234         -
                        })?
         226  +
                        let mut container = Vec::new();
         227  +
                        deser.read_list(member, &mut |deser| {
         228  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         229  +
                            Ok(())
         230  +
                        })?;
         231  +
                        container
  235    232   
                    });
  236    233   
                }
  237    234   
                Some(3) => {
  238    235   
                    builder.bgp_asn_extended = Some(deser.read_string(member)?);
  239    236   
                }
  240    237   
                Some(4) => {
  241    238   
                    builder.customer_gateway_id = Some(deser.read_string(member)?);
  242    239   
                }
  243    240   
                Some(5) => {
  244    241   
                    builder.state = Some(deser.read_string(member)?);
  245    242   
                }
  246    243   
                Some(6) => {
  247    244   
                    builder.r#type = Some(deser.read_string(member)?);
  248    245   
                }
  249    246   
                Some(7) => {
  250    247   
                    builder.ip_address = Some(deser.read_string(member)?);
  251    248   
                }
  252    249   
                Some(8) => {
  253    250   
                    builder.bgp_asn = Some(deser.read_string(member)?);
  254    251   
                }
  255    252   
                _ => {}
  256    253   
            }
  257    254   
            Ok(())
  258    255   
        })?;
  259    256   
        Ok(builder.build())
  260    257   
    }
  261    258   
}
         259  +
impl CustomerGateway {
         260  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         261  +
    pub fn deserialize_with_response(
         262  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         263  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         264  +
        _status: u16,
         265  +
        _body: &[u8],
         266  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         267  +
        Self::deserialize(deserializer)
         268  +
    }
         269  +
}
  262    270   
impl CustomerGateway {
  263    271   
    /// Creates a new builder-style object to manufacture [`CustomerGateway`](crate::types::CustomerGateway).
  264    272   
    pub fn builder() -> crate::types::builders::CustomerGatewayBuilder {
  265    273   
        crate::types::builders::CustomerGatewayBuilder::default()
  266    274   
    }
  267    275   
}
  268    276   
  269    277   
/// A builder for [`CustomerGateway`](crate::types::CustomerGateway).
  270    278   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  271    279   
#[non_exhaustive]

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

@@ -21,21 +197,208 @@
   41     41   
    /// <p>The aggregation period used for the data query.</p>
   42     42   
    pub fn period(&self) -> ::std::option::Option<&crate::types::PeriodType> {
   43     43   
        self.period.as_ref()
   44     44   
    }
   45     45   
}
   46     46   
static DATAQUERY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery", "com.amazonaws.ec2", "DataQuery");
   48     48   
static DATAQUERY_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery$Id", "com.amazonaws.ec2", "DataQuery"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "id",
          51  +
    "Id",
   52     52   
    0,
   53     53   
);
   54     54   
static DATAQUERY_MEMBER_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery$Source", "com.amazonaws.ec2", "DataQuery"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "source",
          57  +
    "Source",
   58     58   
    1,
   59     59   
);
   60     60   
static DATAQUERY_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery$Destination", "com.amazonaws.ec2", "DataQuery"),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "destination",
          63  +
    "Destination",
   64     64   
    2,
   65     65   
);
   66     66   
static DATAQUERY_MEMBER_METRIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery$Metric", "com.amazonaws.ec2", "DataQuery"),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "metric",
          69  +
    "Metric",
   70     70   
    3,
   71     71   
);
   72     72   
static DATAQUERY_MEMBER_STATISTIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery$Statistic", "com.amazonaws.ec2", "DataQuery"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "statistic",
          75  +
    "Statistic",
   76     76   
    4,
   77     77   
);
   78     78   
static DATAQUERY_MEMBER_PERIOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataQuery$Period", "com.amazonaws.ec2", "DataQuery"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "period",
          81  +
    "Period",
   82     82   
    5,
   83     83   
);
   84     84   
static DATAQUERY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    DATAQUERY_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &DATAQUERY_MEMBER_ID,
   89     89   
        &DATAQUERY_MEMBER_SOURCE,
   90     90   
        &DATAQUERY_MEMBER_DESTINATION,
   91     91   
        &DATAQUERY_MEMBER_METRIC,
   92     92   
        &DATAQUERY_MEMBER_STATISTIC,
   93     93   
        &DATAQUERY_MEMBER_PERIOD,
   94     94   
    ],
   95     95   
);
   96     96   
impl DataQuery {
   97     97   
    /// The schema for this shape.
   98     98   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DATAQUERY_SCHEMA;
   99     99   
}
  100    100   
impl ::aws_smithy_schema::serde::SerializableStruct for DataQuery {
  101    101   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  102    102   
    fn serialize_members(
  103    103   
        &self,
  104    104   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  105    105   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        if let Some(ref val) = self.id {
  107    107   
            ser.write_string(&DATAQUERY_MEMBER_ID, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.source {
  110    110   
            ser.write_string(&DATAQUERY_MEMBER_SOURCE, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.destination {
  113    113   
            ser.write_string(&DATAQUERY_MEMBER_DESTINATION, val)?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.metric {
  116    116   
            ser.write_string(&DATAQUERY_MEMBER_METRIC, val.as_str())?;
  117    117   
        }
  118    118   
        if let Some(ref val) = self.statistic {
  119    119   
            ser.write_string(&DATAQUERY_MEMBER_STATISTIC, val.as_str())?;
  120    120   
        }
  121    121   
        if let Some(ref val) = self.period {
  122    122   
            ser.write_string(&DATAQUERY_MEMBER_PERIOD, val.as_str())?;
  123    123   
        }
  124    124   
        Ok(())
  125    125   
    }
  126    126   
}
  127    127   
impl DataQuery {
  128    128   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  129         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  130         -
        deserializer: &mut D,
         129  +
    pub fn deserialize(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  131    131   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  132    132   
        #[allow(unused_variables, unused_mut)]
  133    133   
        let mut builder = Self::builder();
  134    134   
        #[allow(
  135    135   
            unused_variables,
  136    136   
            unreachable_code,
  137    137   
            clippy::single_match,
  138    138   
            clippy::match_single_binding,
  139    139   
            clippy::diverging_sub_expression
  140    140   
        )]
  141         -
        deserializer.read_struct(&DATAQUERY_SCHEMA, (), |_, member, deser| {
         141  +
        deserializer.read_struct(&DATAQUERY_SCHEMA, &mut |member, deser| {
  142    142   
            match member.member_index() {
  143    143   
                Some(0) => {
  144    144   
                    builder.id = Some(deser.read_string(member)?);
  145    145   
                }
  146    146   
                Some(1) => {
  147    147   
                    builder.source = Some(deser.read_string(member)?);
  148    148   
                }
  149    149   
                Some(2) => {
  150    150   
                    builder.destination = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(3) => {
  153    153   
                    builder.metric = Some(crate::types::MetricType::from(deser.read_string(member)?.as_str()));
  154    154   
                }
  155    155   
                Some(4) => {
  156    156   
                    builder.statistic = Some(crate::types::StatisticType::from(deser.read_string(member)?.as_str()));
  157    157   
                }
  158    158   
                Some(5) => {
  159    159   
                    builder.period = Some(crate::types::PeriodType::from(deser.read_string(member)?.as_str()));
  160    160   
                }
  161    161   
                _ => {}
  162    162   
            }
  163    163   
            Ok(())
  164    164   
        })?;
  165    165   
        Ok(builder.build())
  166    166   
    }
  167    167   
}
         168  +
impl DataQuery {
         169  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         170  +
    pub fn deserialize_with_response(
         171  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         172  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         173  +
        _status: u16,
         174  +
        _body: &[u8],
         175  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         176  +
        Self::deserialize(deserializer)
         177  +
    }
         178  +
}
  168    179   
impl DataQuery {
  169    180   
    /// Creates a new builder-style object to manufacture [`DataQuery`](crate::types::DataQuery).
  170    181   
    pub fn builder() -> crate::types::builders::DataQueryBuilder {
  171    182   
        crate::types::builders::DataQueryBuilder::default()
  172    183   
    }
  173    184   
}
  174    185   
  175    186   
/// A builder for [`DataQuery`](crate::types::DataQuery).
  176    187   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  177    188   
#[non_exhaustive]

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

@@ -29,29 +243,251 @@
   49     49   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.metric_points.is_none()`.
   50     50   
    pub fn metric_points(&self) -> &[crate::types::MetricPoint] {
   51     51   
        self.metric_points.as_deref().unwrap_or_default()
   52     52   
    }
   53     53   
}
   54     54   
static DATARESPONSE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse", "com.amazonaws.ec2", "DataResponse");
   56     56   
static DATARESPONSE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$Id", "com.amazonaws.ec2", "DataResponse"),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "id",
          59  +
    "Id",
   60     60   
    0,
   61     61   
)
   62     62   
.with_xml_name("id");
   63     63   
static DATARESPONSE_MEMBER_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$Source", "com.amazonaws.ec2", "DataResponse"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "source",
          66  +
    "Source",
   67     67   
    1,
   68     68   
)
   69     69   
.with_xml_name("source");
   70     70   
static DATARESPONSE_MEMBER_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$Destination", "com.amazonaws.ec2", "DataResponse"),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "destination",
          73  +
    "Destination",
   74     74   
    2,
   75     75   
)
   76     76   
.with_xml_name("destination");
   77     77   
static DATARESPONSE_MEMBER_METRIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$Metric", "com.amazonaws.ec2", "DataResponse"),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "metric",
          80  +
    "Metric",
   81     81   
    3,
   82     82   
)
   83     83   
.with_xml_name("metric");
   84     84   
static DATARESPONSE_MEMBER_STATISTIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$Statistic", "com.amazonaws.ec2", "DataResponse"),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "statistic",
          87  +
    "Statistic",
   88     88   
    4,
   89     89   
)
   90     90   
.with_xml_name("statistic");
   91     91   
static DATARESPONSE_MEMBER_PERIOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$Period", "com.amazonaws.ec2", "DataResponse"),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "period",
          94  +
    "Period",
   95     95   
    5,
   96     96   
)
   97     97   
.with_xml_name("period");
   98     98   
static DATARESPONSE_MEMBER_METRIC_POINTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DataResponse$MetricPoints", "com.amazonaws.ec2", "DataResponse"),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "metric_points",
         101  +
    "MetricPoints",
  102    102   
    6,
  103    103   
)
  104    104   
.with_xml_name("metricPointSet");
  105    105   
static DATARESPONSE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  106    106   
    DATARESPONSE_SCHEMA_ID,
  107    107   
    ::aws_smithy_schema::ShapeType::Structure,
  108    108   
    &[
  109    109   
        &DATARESPONSE_MEMBER_ID,
  110    110   
        &DATARESPONSE_MEMBER_SOURCE,
  111    111   
        &DATARESPONSE_MEMBER_DESTINATION,
  112    112   
        &DATARESPONSE_MEMBER_METRIC,
  113    113   
        &DATARESPONSE_MEMBER_STATISTIC,
  114    114   
        &DATARESPONSE_MEMBER_PERIOD,
  115    115   
        &DATARESPONSE_MEMBER_METRIC_POINTS,
  116    116   
    ],
  117    117   
);
  118    118   
impl DataResponse {
  119    119   
    /// The schema for this shape.
  120    120   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DATARESPONSE_SCHEMA;
  121    121   
}
  122    122   
impl ::aws_smithy_schema::serde::SerializableStruct for DataResponse {
  123    123   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  124    124   
    fn serialize_members(
  125    125   
        &self,
  126    126   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  127    127   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  128    128   
        if let Some(ref val) = self.id {
  129    129   
            ser.write_string(&DATARESPONSE_MEMBER_ID, val)?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.source {
  132    132   
            ser.write_string(&DATARESPONSE_MEMBER_SOURCE, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.destination {
  135    135   
            ser.write_string(&DATARESPONSE_MEMBER_DESTINATION, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.metric {
  138    138   
            ser.write_string(&DATARESPONSE_MEMBER_METRIC, val.as_str())?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.statistic {
  141    141   
            ser.write_string(&DATARESPONSE_MEMBER_STATISTIC, val.as_str())?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.period {
  144    144   
            ser.write_string(&DATARESPONSE_MEMBER_PERIOD, val.as_str())?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.metric_points {
  147    147   
            ser.write_list(
  148    148   
                &DATARESPONSE_MEMBER_METRIC_POINTS,
  149    149   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  150    150   
                    for item in val {
  151    151   
                        ser.write_struct(crate::types::MetricPoint::SCHEMA, item)?;
  152    152   
                    }
  153    153   
                    Ok(())
  154    154   
                },
  155    155   
            )?;
  156    156   
        }
  157    157   
        Ok(())
  158    158   
    }
  159    159   
}
  160    160   
impl DataResponse {
  161    161   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  162         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  163         -
        deserializer: &mut D,
         162  +
    pub fn deserialize(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  164    164   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  165    165   
        #[allow(unused_variables, unused_mut)]
  166    166   
        let mut builder = Self::builder();
  167    167   
        #[allow(
  168    168   
            unused_variables,
  169    169   
            unreachable_code,
  170    170   
            clippy::single_match,
  171    171   
            clippy::match_single_binding,
  172    172   
            clippy::diverging_sub_expression
  173    173   
        )]
  174         -
        deserializer.read_struct(&DATARESPONSE_SCHEMA, (), |_, member, deser| {
         174  +
        deserializer.read_struct(&DATARESPONSE_SCHEMA, &mut |member, deser| {
  175    175   
            match member.member_index() {
  176    176   
                Some(0) => {
  177    177   
                    builder.id = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(1) => {
  180    180   
                    builder.source = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(2) => {
  183    183   
                    builder.destination = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(3) => {
  186    186   
                    builder.metric = Some(crate::types::MetricType::from(deser.read_string(member)?.as_str()));
  187    187   
                }
  188    188   
                Some(4) => {
  189    189   
                    builder.statistic = Some(crate::types::StatisticType::from(deser.read_string(member)?.as_str()));
  190    190   
                }
  191    191   
                Some(5) => {
  192    192   
                    builder.period = Some(crate::types::PeriodType::from(deser.read_string(member)?.as_str()));
  193    193   
                }
  194    194   
                Some(6) => {
  195    195   
                    builder.metric_points = Some({
  196         -
                        let container = if let Some(cap) = deser.container_size() {
  197         -
                            Vec::with_capacity(cap)
  198         -
                        } else {
  199         -
                            Vec::new()
  200         -
                        };
  201         -
                        deser.read_list(member, container, |mut list, deser| {
  202         -
                            list.push(crate::types::MetricPoint::deserialize(deser)?);
  203         -
                            Ok(list)
  204         -
                        })?
         196  +
                        let mut container = Vec::new();
         197  +
                        deser.read_list(member, &mut |deser| {
         198  +
                            container.push(crate::types::MetricPoint::deserialize(deser)?);
         199  +
                            Ok(())
         200  +
                        })?;
         201  +
                        container
  205    202   
                    });
  206    203   
                }
  207    204   
                _ => {}
  208    205   
            }
  209    206   
            Ok(())
  210    207   
        })?;
  211    208   
        Ok(builder.build())
  212    209   
    }
  213    210   
}
         211  +
impl DataResponse {
         212  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         213  +
    pub fn deserialize_with_response(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         215  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         216  +
        _status: u16,
         217  +
        _body: &[u8],
         218  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         219  +
        Self::deserialize(deserializer)
         220  +
    }
         221  +
}
  214    222   
impl DataResponse {
  215    223   
    /// Creates a new builder-style object to manufacture [`DataResponse`](crate::types::DataResponse).
  216    224   
    pub fn builder() -> crate::types::builders::DataResponseBuilder {
  217    225   
        crate::types::builders::DataResponseBuilder::default()
  218    226   
    }
  219    227   
}
  220    228   
  221    229   
/// A builder for [`DataResponse`](crate::types::DataResponse).
  222    230   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  223    231   
#[non_exhaustive]

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

@@ -60,60 +197,197 @@
   80     80   
    "com.amazonaws.ec2",
   81     81   
    "DeclarativePoliciesReport",
   82     82   
);
   83     83   
static DECLARATIVEPOLICIESREPORT_MEMBER_REPORT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ec2#DeclarativePoliciesReport$ReportId",
   86     86   
        "com.amazonaws.ec2",
   87     87   
        "DeclarativePoliciesReport",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "report_id",
          90  +
    "ReportId",
   91     91   
    0,
   92     92   
)
   93     93   
.with_xml_name("reportId");
   94     94   
static DECLARATIVEPOLICIESREPORT_MEMBER_S3_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.ec2#DeclarativePoliciesReport$S3Bucket",
   97     97   
        "com.amazonaws.ec2",
   98     98   
        "DeclarativePoliciesReport",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "s3_bucket",
         101  +
    "S3Bucket",
  102    102   
    1,
  103    103   
)
  104    104   
.with_xml_name("s3Bucket");
  105    105   
static DECLARATIVEPOLICIESREPORT_MEMBER_S3_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.ec2#DeclarativePoliciesReport$S3Prefix",
  108    108   
        "com.amazonaws.ec2",
  109    109   
        "DeclarativePoliciesReport",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "s3_prefix",
         112  +
    "S3Prefix",
  113    113   
    2,
  114    114   
)
  115    115   
.with_xml_name("s3Prefix");
  116    116   
static DECLARATIVEPOLICIESREPORT_MEMBER_TARGET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static(
  118    118   
        "com.amazonaws.ec2#DeclarativePoliciesReport$TargetId",
  119    119   
        "com.amazonaws.ec2",
  120    120   
        "DeclarativePoliciesReport",
  121    121   
    ),
  122    122   
    ::aws_smithy_schema::ShapeType::String,
  123         -
    "target_id",
         123  +
    "TargetId",
  124    124   
    3,
  125    125   
)
  126    126   
.with_xml_name("targetId");
  127    127   
static DECLARATIVEPOLICIESREPORT_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.ec2#DeclarativePoliciesReport$StartTime",
  130    130   
        "com.amazonaws.ec2",
  131    131   
        "DeclarativePoliciesReport",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::Timestamp,
  134         -
    "start_time",
         134  +
    "StartTime",
  135    135   
    4,
  136    136   
)
  137    137   
.with_xml_name("startTime");
  138    138   
static DECLARATIVEPOLICIESREPORT_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.ec2#DeclarativePoliciesReport$EndTime",
  141    141   
        "com.amazonaws.ec2",
  142    142   
        "DeclarativePoliciesReport",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::Timestamp,
  145         -
    "end_time",
         145  +
    "EndTime",
  146    146   
    5,
  147    147   
)
  148    148   
.with_xml_name("endTime");
  149    149   
static DECLARATIVEPOLICIESREPORT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.ec2#DeclarativePoliciesReport$Status",
  152    152   
        "com.amazonaws.ec2",
  153    153   
        "DeclarativePoliciesReport",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "status",
         156  +
    "Status",
  157    157   
    6,
  158    158   
)
  159    159   
.with_xml_name("status");
  160    160   
static DECLARATIVEPOLICIESREPORT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static(
  162    162   
        "com.amazonaws.ec2#DeclarativePoliciesReport$Tags",
  163    163   
        "com.amazonaws.ec2",
  164    164   
        "DeclarativePoliciesReport",
  165    165   
    ),
  166    166   
    ::aws_smithy_schema::ShapeType::List,
  167         -
    "tags",
         167  +
    "Tags",
  168    168   
    7,
  169    169   
)
  170    170   
.with_xml_name("tagSet");
  171    171   
static DECLARATIVEPOLICIESREPORT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  172    172   
    DECLARATIVEPOLICIESREPORT_SCHEMA_ID,
  173    173   
    ::aws_smithy_schema::ShapeType::Structure,
  174    174   
    &[
  175    175   
        &DECLARATIVEPOLICIESREPORT_MEMBER_REPORT_ID,
  176    176   
        &DECLARATIVEPOLICIESREPORT_MEMBER_S3_BUCKET,
  177    177   
        &DECLARATIVEPOLICIESREPORT_MEMBER_S3_PREFIX,
@@ -202,202 +316,324 @@
  222    222   
                    }
  223    223   
                    Ok(())
  224    224   
                },
  225    225   
            )?;
  226    226   
        }
  227    227   
        Ok(())
  228    228   
    }
  229    229   
}
  230    230   
impl DeclarativePoliciesReport {
  231    231   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  232         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  233         -
        deserializer: &mut D,
         232  +
    pub fn deserialize(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  234    234   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  235    235   
        #[allow(unused_variables, unused_mut)]
  236    236   
        let mut builder = Self::builder();
  237    237   
        #[allow(
  238    238   
            unused_variables,
  239    239   
            unreachable_code,
  240    240   
            clippy::single_match,
  241    241   
            clippy::match_single_binding,
  242    242   
            clippy::diverging_sub_expression
  243    243   
        )]
  244         -
        deserializer.read_struct(&DECLARATIVEPOLICIESREPORT_SCHEMA, (), |_, member, deser| {
         244  +
        deserializer.read_struct(&DECLARATIVEPOLICIESREPORT_SCHEMA, &mut |member, deser| {
  245    245   
            match member.member_index() {
  246    246   
                Some(0) => {
  247    247   
                    builder.report_id = Some(deser.read_string(member)?);
  248    248   
                }
  249    249   
                Some(1) => {
  250    250   
                    builder.s3_bucket = Some(deser.read_string(member)?);
  251    251   
                }
  252    252   
                Some(2) => {
  253    253   
                    builder.s3_prefix = Some(deser.read_string(member)?);
  254    254   
                }
  255    255   
                Some(3) => {
  256    256   
                    builder.target_id = Some(deser.read_string(member)?);
  257    257   
                }
  258    258   
                Some(4) => {
  259    259   
                    builder.start_time = Some(deser.read_timestamp(member)?);
  260    260   
                }
  261    261   
                Some(5) => {
  262    262   
                    builder.end_time = Some(deser.read_timestamp(member)?);
  263    263   
                }
  264    264   
                Some(6) => {
  265    265   
                    builder.status = Some(crate::types::ReportState::from(deser.read_string(member)?.as_str()));
  266    266   
                }
  267    267   
                Some(7) => {
  268    268   
                    builder.tags = Some({
  269         -
                        let container = if let Some(cap) = deser.container_size() {
  270         -
                            Vec::with_capacity(cap)
  271         -
                        } else {
  272         -
                            Vec::new()
  273         -
                        };
  274         -
                        deser.read_list(member, container, |mut list, deser| {
  275         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  276         -
                            Ok(list)
  277         -
                        })?
         269  +
                        let mut container = Vec::new();
         270  +
                        deser.read_list(member, &mut |deser| {
         271  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         272  +
                            Ok(())
         273  +
                        })?;
         274  +
                        container
  278    275   
                    });
  279    276   
                }
  280    277   
                _ => {}
  281    278   
            }
  282    279   
            Ok(())
  283    280   
        })?;
  284    281   
        Ok(builder.build())
  285    282   
    }
  286    283   
}
         284  +
impl DeclarativePoliciesReport {
         285  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         286  +
    pub fn deserialize_with_response(
         287  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         288  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         289  +
        _status: u16,
         290  +
        _body: &[u8],
         291  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         292  +
        Self::deserialize(deserializer)
         293  +
    }
         294  +
}
  287    295   
impl DeclarativePoliciesReport {
  288    296   
    /// Creates a new builder-style object to manufacture [`DeclarativePoliciesReport`](crate::types::DeclarativePoliciesReport).
  289    297   
    pub fn builder() -> crate::types::builders::DeclarativePoliciesReportBuilder {
  290    298   
        crate::types::builders::DeclarativePoliciesReportBuilder::default()
  291    299   
    }
  292    300   
}
  293    301   
  294    302   
/// A builder for [`DeclarativePoliciesReport`](crate::types::DeclarativePoliciesReport).
  295    303   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  296    304   
#[non_exhaustive]

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The description for the error code.</p>
   18     18   
    pub fn message(&self) -> ::std::option::Option<&str> {
   19     19   
        self.message.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static DELETEFLEETERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DeleteFleetError", "com.amazonaws.ec2", "DeleteFleetError");
   24     24   
static DELETEFLEETERROR_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DeleteFleetError$Code", "com.amazonaws.ec2", "DeleteFleetError"),
   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 DELETEFLEETERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#DeleteFleetError$Message", "com.amazonaws.ec2", "DeleteFleetError"),
   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 DELETEFLEETERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    DELETEFLEETERROR_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&DELETEFLEETERROR_MEMBER_CODE, &DELETEFLEETERROR_MEMBER_MESSAGE],
   42     42   
);
   43     43   
impl DeleteFleetError {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEFLEETERROR_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteFleetError {
   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(&DELETEFLEETERROR_MEMBER_CODE, val.as_str())?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.message {
   57     57   
            ser.write_string(&DELETEFLEETERROR_MEMBER_MESSAGE, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl DeleteFleetError {
   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(&DELETEFLEETERROR_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&DELETEFLEETERROR_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.code = Some(crate::types::DeleteFleetErrorCode::from(deser.read_string(member)?.as_str()));
   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 DeleteFleetError {
          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 DeleteFleetError {
   92    103   
    /// Creates a new builder-style object to manufacture [`DeleteFleetError`](crate::types::DeleteFleetError).
   93    104   
    pub fn builder() -> crate::types::builders::DeleteFleetErrorBuilder {
   94    105   
        crate::types::builders::DeleteFleetErrorBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`DeleteFleetError`](crate::types::DeleteFleetError).
   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/_delete_fleet_error_item.rs

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

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

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

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

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

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

@@ -11,11 +160,171 @@
   31     31   
    "DeleteLaunchTemplateVersionsResponseSuccessItem",
   32     32   
);
   33     33   
static DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_LAUNCH_TEMPLATE_ID: ::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#DeleteLaunchTemplateVersionsResponseSuccessItem$LaunchTemplateId",
   37     37   
            "com.amazonaws.ec2",
   38     38   
            "DeleteLaunchTemplateVersionsResponseSuccessItem",
   39     39   
        ),
   40     40   
        ::aws_smithy_schema::ShapeType::String,
   41         -
        "launch_template_id",
          41  +
        "LaunchTemplateId",
   42     42   
        0,
   43     43   
    )
   44     44   
    .with_xml_name("launchTemplateId");
   45     45   
static DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_LAUNCH_TEMPLATE_NAME: ::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#DeleteLaunchTemplateVersionsResponseSuccessItem$LaunchTemplateName",
   49     49   
            "com.amazonaws.ec2",
   50     50   
            "DeleteLaunchTemplateVersionsResponseSuccessItem",
   51     51   
        ),
   52     52   
        ::aws_smithy_schema::ShapeType::String,
   53         -
        "launch_template_name",
          53  +
        "LaunchTemplateName",
   54     54   
        1,
   55     55   
    )
   56     56   
    .with_xml_name("launchTemplateName");
   57     57   
static DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_VERSION_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.ec2#DeleteLaunchTemplateVersionsResponseSuccessItem$VersionNumber",
   60     60   
        "com.amazonaws.ec2",
   61     61   
        "DeleteLaunchTemplateVersionsResponseSuccessItem",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Long,
   64         -
    "version_number",
          64  +
    "VersionNumber",
   65     65   
    2,
   66     66   
)
   67     67   
.with_xml_name("versionNumber");
   68     68   
static DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_LAUNCH_TEMPLATE_ID,
   73     73   
        &DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_LAUNCH_TEMPLATE_NAME,
   74     74   
        &DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_VERSION_NUMBER,
   75     75   
    ],
   76     76   
);
   77     77   
impl DeleteLaunchTemplateVersionsResponseSuccessItem {
   78     78   
    /// The schema for this shape.
   79     79   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_SCHEMA;
   80     80   
}
   81     81   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteLaunchTemplateVersionsResponseSuccessItem {
   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.launch_template_id {
   88     88   
            ser.write_string(&DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_LAUNCH_TEMPLATE_ID, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.launch_template_name {
   91     91   
            ser.write_string(&DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_LAUNCH_TEMPLATE_NAME, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.version_number {
   94     94   
            ser.write_long(&DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_MEMBER_VERSION_NUMBER, *val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl DeleteLaunchTemplateVersionsResponseSuccessItem {
  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(&DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&DELETELAUNCHTEMPLATEVERSIONSRESPONSESUCCESSITEM_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.launch_template_id = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.launch_template_name = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.version_number = Some(deser.read_long(member)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
  128    128   
        Ok(builder.build())
  129    129   
    }
  130    130   
}
         131  +
impl DeleteLaunchTemplateVersionsResponseSuccessItem {
         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 DeleteLaunchTemplateVersionsResponseSuccessItem {
  132    143   
    /// Creates a new builder-style object to manufacture [`DeleteLaunchTemplateVersionsResponseSuccessItem`](crate::types::DeleteLaunchTemplateVersionsResponseSuccessItem).
  133    144   
    pub fn builder() -> crate::types::builders::DeleteLaunchTemplateVersionsResponseSuccessItemBuilder {
  134    145   
        crate::types::builders::DeleteLaunchTemplateVersionsResponseSuccessItemBuilder::default()
  135    146   
    }
  136    147   
}
  137    148   
  138    149   
/// A builder for [`DeleteLaunchTemplateVersionsResponseSuccessItem`](crate::types::DeleteLaunchTemplateVersionsResponseSuccessItem).
  139    150   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  140    151   
#[non_exhaustive]

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

@@ -4,4 +136,147 @@
   24     24   
    "com.amazonaws.ec2",
   25     25   
    "DeleteQueuedReservedInstancesError",
   26     26   
);
   27     27   
static DELETEQUEUEDRESERVEDINSTANCESERROR_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#DeleteQueuedReservedInstancesError$Code",
   30     30   
        "com.amazonaws.ec2",
   31     31   
        "DeleteQueuedReservedInstancesError",
   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 DELETEQUEUEDRESERVEDINSTANCESERROR_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#DeleteQueuedReservedInstancesError$Message",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "DeleteQueuedReservedInstancesError",
   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 DELETEQUEUEDRESERVEDINSTANCESERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    DELETEQUEUEDRESERVEDINSTANCESERROR_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &DELETEQUEUEDRESERVEDINSTANCESERROR_MEMBER_CODE,
   54     54   
        &DELETEQUEUEDRESERVEDINSTANCESERROR_MEMBER_MESSAGE,
   55     55   
    ],
   56     56   
);
   57     57   
impl DeleteQueuedReservedInstancesError {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETEQUEUEDRESERVEDINSTANCESERROR_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteQueuedReservedInstancesError {
   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(&DELETEQUEUEDRESERVEDINSTANCESERROR_MEMBER_CODE, val.as_str())?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.message {
   71     71   
            ser.write_string(&DELETEQUEUEDRESERVEDINSTANCESERROR_MEMBER_MESSAGE, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl DeleteQueuedReservedInstancesError {
   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(&DELETEQUEUEDRESERVEDINSTANCESERROR_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&DELETEQUEUEDRESERVEDINSTANCESERROR_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.code = Some(crate::types::DeleteQueuedReservedInstancesErrorCode::from(
   94     94   
                        deser.read_string(member)?.as_str(),
   95     95   
                    ));
   96     96   
                }
   97     97   
                Some(1) => {
   98     98   
                    builder.message = Some(deser.read_string(member)?);
   99     99   
                }
  100    100   
                _ => {}
  101    101   
            }
  102    102   
            Ok(())
  103    103   
        })?;
  104    104   
        Ok(builder.build())
  105    105   
    }
  106    106   
}
         107  +
impl DeleteQueuedReservedInstancesError {
         108  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         109  +
    pub fn deserialize_with_response(
         110  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         111  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         112  +
        _status: u16,
         113  +
        _body: &[u8],
         114  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         115  +
        Self::deserialize(deserializer)
         116  +
    }
         117  +
}
  107    118   
impl DeleteQueuedReservedInstancesError {
  108    119   
    /// Creates a new builder-style object to manufacture [`DeleteQueuedReservedInstancesError`](crate::types::DeleteQueuedReservedInstancesError).
  109    120   
    pub fn builder() -> crate::types::builders::DeleteQueuedReservedInstancesErrorBuilder {
  110    121   
        crate::types::builders::DeleteQueuedReservedInstancesErrorBuilder::default()
  111    122   
    }
  112    123   
}
  113    124   
  114    125   
/// A builder for [`DeleteQueuedReservedInstancesError`](crate::types::DeleteQueuedReservedInstancesError).
  115    126   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  116    127   
#[non_exhaustive]

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

@@ -30,30 +157,168 @@
   50     50   
    "com.amazonaws.ec2",
   51     51   
    "DeleteSnapshotReturnCode",
   52     52   
);
   53     53   
static DELETESNAPSHOTRETURNCODE_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.ec2#DeleteSnapshotReturnCode$SnapshotId",
   56     56   
        "com.amazonaws.ec2",
   57     57   
        "DeleteSnapshotReturnCode",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "snapshot_id",
          60  +
    "SnapshotId",
   61     61   
    0,
   62     62   
)
   63     63   
.with_xml_name("snapshotId");
   64     64   
static DELETESNAPSHOTRETURNCODE_MEMBER_RETURN_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.ec2#DeleteSnapshotReturnCode$ReturnCode",
   67     67   
        "com.amazonaws.ec2",
   68     68   
        "DeleteSnapshotReturnCode",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "return_code",
          71  +
    "ReturnCode",
   72     72   
    1,
   73     73   
)
   74     74   
.with_xml_name("returnCode");
   75     75   
static DELETESNAPSHOTRETURNCODE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   76     76   
    DELETESNAPSHOTRETURNCODE_SCHEMA_ID,
   77     77   
    ::aws_smithy_schema::ShapeType::Structure,
   78     78   
    &[&DELETESNAPSHOTRETURNCODE_MEMBER_SNAPSHOT_ID, &DELETESNAPSHOTRETURNCODE_MEMBER_RETURN_CODE],
   79     79   
);
   80     80   
impl DeleteSnapshotReturnCode {
   81     81   
    /// The schema for this shape.
   82     82   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELETESNAPSHOTRETURNCODE_SCHEMA;
   83     83   
}
   84     84   
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteSnapshotReturnCode {
   85     85   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   86     86   
    fn serialize_members(
   87     87   
        &self,
   88     88   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   89     89   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   90     90   
        if let Some(ref val) = self.snapshot_id {
   91     91   
            ser.write_string(&DELETESNAPSHOTRETURNCODE_MEMBER_SNAPSHOT_ID, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.return_code {
   94     94   
            ser.write_string(&DELETESNAPSHOTRETURNCODE_MEMBER_RETURN_CODE, val.as_str())?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl DeleteSnapshotReturnCode {
  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(&DELETESNAPSHOTRETURNCODE_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&DELETESNAPSHOTRETURNCODE_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.return_code = Some(crate::types::SnapshotReturnCodes::from(deser.read_string(member)?.as_str()));
  120    120   
                }
  121    121   
                _ => {}
  122    122   
            }
  123    123   
            Ok(())
  124    124   
        })?;
  125    125   
        Ok(builder.build())
  126    126   
    }
  127    127   
}
         128  +
impl DeleteSnapshotReturnCode {
         129  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         130  +
    pub fn deserialize_with_response(
         131  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         132  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         133  +
        _status: u16,
         134  +
        _body: &[u8],
         135  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         136  +
        Self::deserialize(deserializer)
         137  +
    }
         138  +
}
  128    139   
impl DeleteSnapshotReturnCode {
  129    140   
    /// Creates a new builder-style object to manufacture [`DeleteSnapshotReturnCode`](crate::types::DeleteSnapshotReturnCode).
  130    141   
    pub fn builder() -> crate::types::builders::DeleteSnapshotReturnCodeBuilder {
  131    142   
        crate::types::builders::DeleteSnapshotReturnCodeBuilder::default()
  132    143   
    }
  133    144   
}
  134    145   
  135    146   
/// A builder for [`DeleteSnapshotReturnCode`](crate::types::DeleteSnapshotReturnCode).
  136    147   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  137    148   
#[non_exhaustive]