AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

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

@@ -9,9 +163,174 @@
   29     29   
    /// <p>Describes the memory available to the GPU accelerator.</p>
   30     30   
    pub fn memory_info(&self) -> ::std::option::Option<&crate::types::GpuDeviceMemoryInfo> {
   31     31   
        self.memory_info.as_ref()
   32     32   
    }
   33     33   
}
   34     34   
static GPUDEVICEINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuDeviceInfo", "com.amazonaws.ec2", "GpuDeviceInfo");
   36     36   
static GPUDEVICEINFO_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuDeviceInfo$Name", "com.amazonaws.ec2", "GpuDeviceInfo"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "name",
          39  +
    "Name",
   40     40   
    0,
   41     41   
)
   42     42   
.with_xml_name("name");
   43     43   
static GPUDEVICEINFO_MEMBER_MANUFACTURER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuDeviceInfo$Manufacturer", "com.amazonaws.ec2", "GpuDeviceInfo"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "manufacturer",
          46  +
    "Manufacturer",
   47     47   
    1,
   48     48   
)
   49     49   
.with_xml_name("manufacturer");
   50     50   
static GPUDEVICEINFO_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuDeviceInfo$Count", "com.amazonaws.ec2", "GpuDeviceInfo"),
   52     52   
    ::aws_smithy_schema::ShapeType::Integer,
   53         -
    "count",
          53  +
    "Count",
   54     54   
    2,
   55     55   
)
   56     56   
.with_xml_name("count");
   57     57   
static GPUDEVICEINFO_MEMBER_MEMORY_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuDeviceInfo$MemoryInfo", "com.amazonaws.ec2", "GpuDeviceInfo"),
   59     59   
    ::aws_smithy_schema::ShapeType::Structure,
   60         -
    "memory_info",
          60  +
    "MemoryInfo",
   61     61   
    3,
   62     62   
)
   63     63   
.with_xml_name("memoryInfo");
   64     64   
static GPUDEVICEINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    GPUDEVICEINFO_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &GPUDEVICEINFO_MEMBER_NAME,
   69     69   
        &GPUDEVICEINFO_MEMBER_MANUFACTURER,
   70     70   
        &GPUDEVICEINFO_MEMBER_COUNT,
   71     71   
        &GPUDEVICEINFO_MEMBER_MEMORY_INFO,
   72     72   
    ],
   73     73   
);
   74     74   
impl GpuDeviceInfo {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GPUDEVICEINFO_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for GpuDeviceInfo {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.name {
   85     85   
            ser.write_string(&GPUDEVICEINFO_MEMBER_NAME, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.manufacturer {
   88     88   
            ser.write_string(&GPUDEVICEINFO_MEMBER_MANUFACTURER, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.count {
   91     91   
            ser.write_integer(&GPUDEVICEINFO_MEMBER_COUNT, *val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.memory_info {
   94     94   
            ser.write_struct(&GPUDEVICEINFO_MEMBER_MEMORY_INFO, val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl GpuDeviceInfo {
  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(&GPUDEVICEINFO_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&GPUDEVICEINFO_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.name = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.manufacturer = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.count = Some(deser.read_integer(member)?);
  123    123   
                }
  124    124   
                Some(3) => {
  125    125   
                    builder.memory_info = Some(crate::types::GpuDeviceMemoryInfo::deserialize(deser)?);
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl GpuDeviceInfo {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
  134    145   
impl GpuDeviceInfo {
  135    146   
    /// Creates a new builder-style object to manufacture [`GpuDeviceInfo`](crate::types::GpuDeviceInfo).
  136    147   
    pub fn builder() -> crate::types::builders::GpuDeviceInfoBuilder {
  137    148   
        crate::types::builders::GpuDeviceInfoBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`GpuDeviceInfo`](crate::types::GpuDeviceInfo).
  142    153   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    154   
#[non_exhaustive]

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

@@ -1,1 +105,116 @@
   15     15   
}
   16     16   
static GPUDEVICEMEMORYINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuDeviceMemoryInfo", "com.amazonaws.ec2", "GpuDeviceMemoryInfo");
   18     18   
static GPUDEVICEMEMORYINFO_MEMBER_SIZE_IN_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.ec2#GpuDeviceMemoryInfo$SizeInMiB",
   21     21   
        "com.amazonaws.ec2",
   22     22   
        "GpuDeviceMemoryInfo",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::Integer,
   25         -
    "size_in_mib",
          25  +
    "SizeInMiB",
   26     26   
    0,
   27     27   
)
   28     28   
.with_xml_name("sizeInMiB");
   29     29   
static GPUDEVICEMEMORYINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   30     30   
    GPUDEVICEMEMORYINFO_SCHEMA_ID,
   31     31   
    ::aws_smithy_schema::ShapeType::Structure,
   32     32   
    &[&GPUDEVICEMEMORYINFO_MEMBER_SIZE_IN_MIB],
   33     33   
);
   34     34   
impl GpuDeviceMemoryInfo {
   35     35   
    /// The schema for this shape.
   36     36   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GPUDEVICEMEMORYINFO_SCHEMA;
   37     37   
}
   38     38   
impl ::aws_smithy_schema::serde::SerializableStruct for GpuDeviceMemoryInfo {
   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.size_in_mib {
   45     45   
            ser.write_integer(&GPUDEVICEMEMORYINFO_MEMBER_SIZE_IN_MIB, *val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl GpuDeviceMemoryInfo {
   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(&GPUDEVICEMEMORYINFO_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&GPUDEVICEMEMORYINFO_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.size_in_mib = 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 GpuDeviceMemoryInfo {
          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 GpuDeviceMemoryInfo {
   77     88   
    /// Creates a new builder-style object to manufacture [`GpuDeviceMemoryInfo`](crate::types::GpuDeviceMemoryInfo).
   78     89   
    pub fn builder() -> crate::types::builders::GpuDeviceMemoryInfoBuilder {
   79     90   
        crate::types::builders::GpuDeviceMemoryInfoBuilder::default()
   80     91   
    }
   81     92   
}
   82     93   
   83     94   
/// A builder for [`GpuDeviceMemoryInfo`](crate::types::GpuDeviceMemoryInfo).
   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/_gpu_info.rs

@@ -1,1 +137,145 @@
   19     19   
    /// <p>The total size of the memory for the GPU accelerators for the instance type, in MiB.</p>
   20     20   
    pub fn total_gpu_memory_in_mib(&self) -> ::std::option::Option<i32> {
   21     21   
        self.total_gpu_memory_in_mib
   22     22   
    }
   23     23   
}
   24     24   
static GPUINFO_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuInfo", "com.amazonaws.ec2", "GpuInfo");
   26     26   
static GPUINFO_MEMBER_GPUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuInfo$Gpus", "com.amazonaws.ec2", "GpuInfo"),
   28     28   
    ::aws_smithy_schema::ShapeType::List,
   29         -
    "gpus",
          29  +
    "Gpus",
   30     30   
    0,
   31     31   
)
   32     32   
.with_xml_name("gpus");
   33     33   
static GPUINFO_MEMBER_TOTAL_GPU_MEMORY_IN_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GpuInfo$TotalGpuMemoryInMiB", "com.amazonaws.ec2", "GpuInfo"),
   35     35   
    ::aws_smithy_schema::ShapeType::Integer,
   36         -
    "total_gpu_memory_in_mib",
          36  +
    "TotalGpuMemoryInMiB",
   37     37   
    1,
   38     38   
)
   39     39   
.with_xml_name("totalGpuMemoryInMiB");
   40     40   
static GPUINFO_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   41     41   
    GPUINFO_SCHEMA_ID,
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43     43   
    &[&GPUINFO_MEMBER_GPUS, &GPUINFO_MEMBER_TOTAL_GPU_MEMORY_IN_MIB],
   44     44   
);
   45     45   
impl GpuInfo {
   46     46   
    /// The schema for this shape.
   47     47   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GPUINFO_SCHEMA;
   48     48   
}
   49     49   
impl ::aws_smithy_schema::serde::SerializableStruct for GpuInfo {
   50     50   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   51     51   
    fn serialize_members(
   52     52   
        &self,
   53     53   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   54     54   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   55     55   
        if let Some(ref val) = self.gpus {
   56     56   
            ser.write_list(&GPUINFO_MEMBER_GPUS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   57     57   
                for item in val {
   58     58   
                    ser.write_struct(crate::types::GpuDeviceInfo::SCHEMA, item)?;
   59     59   
                }
   60     60   
                Ok(())
   61     61   
            })?;
   62     62   
        }
   63     63   
        if let Some(ref val) = self.total_gpu_memory_in_mib {
   64     64   
            ser.write_integer(&GPUINFO_MEMBER_TOTAL_GPU_MEMORY_IN_MIB, *val)?;
   65     65   
        }
   66     66   
        Ok(())
   67     67   
    }
   68     68   
}
   69     69   
impl GpuInfo {
   70     70   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   71         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   72         -
        deserializer: &mut D,
          71  +
    pub fn deserialize(
          72  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   73     73   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   74     74   
        #[allow(unused_variables, unused_mut)]
   75     75   
        let mut builder = Self::builder();
   76     76   
        #[allow(
   77     77   
            unused_variables,
   78     78   
            unreachable_code,
   79     79   
            clippy::single_match,
   80     80   
            clippy::match_single_binding,
   81     81   
            clippy::diverging_sub_expression
   82     82   
        )]
   83         -
        deserializer.read_struct(&GPUINFO_SCHEMA, (), |_, member, deser| {
          83  +
        deserializer.read_struct(&GPUINFO_SCHEMA, &mut |member, deser| {
   84     84   
            match member.member_index() {
   85     85   
                Some(0) => {
   86     86   
                    builder.gpus = Some({
   87         -
                        let container = if let Some(cap) = deser.container_size() {
   88         -
                            Vec::with_capacity(cap)
   89         -
                        } else {
   90         -
                            Vec::new()
   91         -
                        };
   92         -
                        deser.read_list(member, container, |mut list, deser| {
   93         -
                            list.push(crate::types::GpuDeviceInfo::deserialize(deser)?);
   94         -
                            Ok(list)
   95         -
                        })?
          87  +
                        let mut container = Vec::new();
          88  +
                        deser.read_list(member, &mut |deser| {
          89  +
                            container.push(crate::types::GpuDeviceInfo::deserialize(deser)?);
          90  +
                            Ok(())
          91  +
                        })?;
          92  +
                        container
   96     93   
                    });
   97     94   
                }
   98     95   
                Some(1) => {
   99     96   
                    builder.total_gpu_memory_in_mib = Some(deser.read_integer(member)?);
  100     97   
                }
  101     98   
                _ => {}
  102     99   
            }
  103    100   
            Ok(())
  104    101   
        })?;
  105    102   
        Ok(builder.build())
  106    103   
    }
  107    104   
}
         105  +
impl GpuInfo {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         107  +
    pub fn deserialize_with_response(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         110  +
        _status: u16,
         111  +
        _body: &[u8],
         112  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         113  +
        Self::deserialize(deserializer)
         114  +
    }
         115  +
}
  108    116   
impl GpuInfo {
  109    117   
    /// Creates a new builder-style object to manufacture [`GpuInfo`](crate::types::GpuInfo).
  110    118   
    pub fn builder() -> crate::types::builders::GpuInfoBuilder {
  111    119   
        crate::types::builders::GpuInfoBuilder::default()
  112    120   
    }
  113    121   
}
  114    122   
  115    123   
/// A builder for [`GpuInfo`](crate::types::GpuInfo).
  116    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  117    125   
#[non_exhaustive]

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The name of the security group.</p>
   18     18   
    pub fn group_name(&self) -> ::std::option::Option<&str> {
   19     19   
        self.group_name.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static GROUPIDENTIFIER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GroupIdentifier", "com.amazonaws.ec2", "GroupIdentifier");
   24     24   
static GROUPIDENTIFIER_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GroupIdentifier$GroupId", "com.amazonaws.ec2", "GroupIdentifier"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "group_id",
          27  +
    "GroupId",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("groupId");
   31     31   
static GROUPIDENTIFIER_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#GroupIdentifier$GroupName", "com.amazonaws.ec2", "GroupIdentifier"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "group_name",
          34  +
    "GroupName",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("groupName");
   38     38   
static GROUPIDENTIFIER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    GROUPIDENTIFIER_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&GROUPIDENTIFIER_MEMBER_GROUP_ID, &GROUPIDENTIFIER_MEMBER_GROUP_NAME],
   42     42   
);
   43     43   
impl GroupIdentifier {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GROUPIDENTIFIER_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for GroupIdentifier {
   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.group_id {
   54     54   
            ser.write_string(&GROUPIDENTIFIER_MEMBER_GROUP_ID, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.group_name {
   57     57   
            ser.write_string(&GROUPIDENTIFIER_MEMBER_GROUP_NAME, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl GroupIdentifier {
   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(&GROUPIDENTIFIER_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&GROUPIDENTIFIER_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.group_id = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.group_name = 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 GroupIdentifier {
          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 GroupIdentifier {
   92    103   
    /// Creates a new builder-style object to manufacture [`GroupIdentifier`](crate::types::GroupIdentifier).
   93    104   
    pub fn builder() -> crate::types::builders::GroupIdentifierBuilder {
   94    105   
        crate::types::builders::GroupIdentifierBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`GroupIdentifier`](crate::types::GroupIdentifier).
   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/_hibernation_options.rs

@@ -1,1 +105,116 @@
   15     15   
}
   16     16   
static HIBERNATIONOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HibernationOptions", "com.amazonaws.ec2", "HibernationOptions");
   18     18   
static HIBERNATIONOPTIONS_MEMBER_CONFIGURED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.ec2#HibernationOptions$Configured",
   21     21   
        "com.amazonaws.ec2",
   22     22   
        "HibernationOptions",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::Boolean,
   25         -
    "configured",
          25  +
    "Configured",
   26     26   
    0,
   27     27   
)
   28     28   
.with_xml_name("configured");
   29     29   
static HIBERNATIONOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   30     30   
    HIBERNATIONOPTIONS_SCHEMA_ID,
   31     31   
    ::aws_smithy_schema::ShapeType::Structure,
   32     32   
    &[&HIBERNATIONOPTIONS_MEMBER_CONFIGURED],
   33     33   
);
   34     34   
impl HibernationOptions {
   35     35   
    /// The schema for this shape.
   36     36   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HIBERNATIONOPTIONS_SCHEMA;
   37     37   
}
   38     38   
impl ::aws_smithy_schema::serde::SerializableStruct for HibernationOptions {
   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.configured {
   45     45   
            ser.write_boolean(&HIBERNATIONOPTIONS_MEMBER_CONFIGURED, *val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl HibernationOptions {
   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(&HIBERNATIONOPTIONS_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&HIBERNATIONOPTIONS_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.configured = Some(deser.read_boolean(member)?);
   68     68   
                }
   69     69   
                _ => {}
   70     70   
            }
   71     71   
            Ok(())
   72     72   
        })?;
   73     73   
        Ok(builder.build())
   74     74   
    }
   75     75   
}
          76  +
impl HibernationOptions {
          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 HibernationOptions {
   77     88   
    /// Creates a new builder-style object to manufacture [`HibernationOptions`](crate::types::HibernationOptions).
   78     89   
    pub fn builder() -> crate::types::builders::HibernationOptionsBuilder {
   79     90   
        crate::types::builders::HibernationOptionsBuilder::default()
   80     91   
    }
   81     92   
}
   82     93   
   83     94   
/// A builder for [`HibernationOptions`](crate::types::HibernationOptions).
   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/_hibernation_options_request.rs

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

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

@@ -23,23 +163,174 @@
   43     43   
    /// <p>The date and time of the event, in UTC format (for example, <i>YYYY</i>-<i>MM</i>-<i>DD</i>T<i>HH</i>:<i>MM</i>:<i>SS</i>Z).</p>
   44     44   
    pub fn timestamp(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   45     45   
        self.timestamp.as_ref()
   46     46   
    }
   47     47   
}
   48     48   
static HISTORYRECORD_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HistoryRecord", "com.amazonaws.ec2", "HistoryRecord");
   50     50   
static HISTORYRECORD_MEMBER_EVENT_INFORMATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HistoryRecord$EventInformation", "com.amazonaws.ec2", "HistoryRecord"),
   52     52   
    ::aws_smithy_schema::ShapeType::Structure,
   53         -
    "event_information",
          53  +
    "EventInformation",
   54     54   
    0,
   55     55   
)
   56     56   
.with_xml_name("eventInformation");
   57     57   
static HISTORYRECORD_MEMBER_EVENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HistoryRecord$EventType", "com.amazonaws.ec2", "HistoryRecord"),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "event_type",
          60  +
    "EventType",
   61     61   
    1,
   62     62   
)
   63     63   
.with_xml_name("eventType");
   64     64   
static HISTORYRECORD_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HistoryRecord$Timestamp", "com.amazonaws.ec2", "HistoryRecord"),
   66     66   
    ::aws_smithy_schema::ShapeType::Timestamp,
   67         -
    "timestamp",
          67  +
    "Timestamp",
   68     68   
    2,
   69     69   
)
   70     70   
.with_xml_name("timestamp");
   71     71   
static HISTORYRECORD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   72     72   
    HISTORYRECORD_SCHEMA_ID,
   73     73   
    ::aws_smithy_schema::ShapeType::Structure,
   74     74   
    &[
   75     75   
        &HISTORYRECORD_MEMBER_EVENT_INFORMATION,
   76     76   
        &HISTORYRECORD_MEMBER_EVENT_TYPE,
   77     77   
        &HISTORYRECORD_MEMBER_TIMESTAMP,
   78     78   
    ],
   79     79   
);
   80     80   
impl HistoryRecord {
   81     81   
    /// The schema for this shape.
   82     82   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HISTORYRECORD_SCHEMA;
   83     83   
}
   84     84   
impl ::aws_smithy_schema::serde::SerializableStruct for HistoryRecord {
   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.event_information {
   91     91   
            ser.write_struct(&HISTORYRECORD_MEMBER_EVENT_INFORMATION, val)?;
   92     92   
        }
   93     93   
        if let Some(ref val) = self.event_type {
   94     94   
            ser.write_string(&HISTORYRECORD_MEMBER_EVENT_TYPE, val.as_str())?;
   95     95   
        }
   96     96   
        if let Some(ref val) = self.timestamp {
   97     97   
            ser.write_timestamp(&HISTORYRECORD_MEMBER_TIMESTAMP, val)?;
   98     98   
        }
   99     99   
        Ok(())
  100    100   
    }
  101    101   
}
  102    102   
impl HistoryRecord {
  103    103   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  104         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  105         -
        deserializer: &mut D,
         104  +
    pub fn deserialize(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  106    106   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  107    107   
        #[allow(unused_variables, unused_mut)]
  108    108   
        let mut builder = Self::builder();
  109    109   
        #[allow(
  110    110   
            unused_variables,
  111    111   
            unreachable_code,
  112    112   
            clippy::single_match,
  113    113   
            clippy::match_single_binding,
  114    114   
            clippy::diverging_sub_expression
  115    115   
        )]
  116         -
        deserializer.read_struct(&HISTORYRECORD_SCHEMA, (), |_, member, deser| {
         116  +
        deserializer.read_struct(&HISTORYRECORD_SCHEMA, &mut |member, deser| {
  117    117   
            match member.member_index() {
  118    118   
                Some(0) => {
  119    119   
                    builder.event_information = Some(crate::types::EventInformation::deserialize(deser)?);
  120    120   
                }
  121    121   
                Some(1) => {
  122    122   
                    builder.event_type = Some(crate::types::EventType::from(deser.read_string(member)?.as_str()));
  123    123   
                }
  124    124   
                Some(2) => {
  125    125   
                    builder.timestamp = Some(deser.read_timestamp(member)?);
  126    126   
                }
  127    127   
                _ => {}
  128    128   
            }
  129    129   
            Ok(())
  130    130   
        })?;
  131    131   
        Ok(builder.build())
  132    132   
    }
  133    133   
}
         134  +
impl HistoryRecord {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
  134    145   
impl HistoryRecord {
  135    146   
    /// Creates a new builder-style object to manufacture [`HistoryRecord`](crate::types::HistoryRecord).
  136    147   
    pub fn builder() -> crate::types::builders::HistoryRecordBuilder {
  137    148   
        crate::types::builders::HistoryRecordBuilder::default()
  138    149   
    }
  139    150   
}
  140    151   
  141    152   
/// A builder for [`HistoryRecord`](crate::types::HistoryRecord).
  142    153   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    154   
#[non_exhaustive]

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

@@ -7,7 +155,166 @@
   27     27   
}
   28     28   
static HISTORYRECORDENTRY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HistoryRecordEntry", "com.amazonaws.ec2", "HistoryRecordEntry");
   30     30   
static HISTORYRECORDENTRY_MEMBER_EVENT_INFORMATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.ec2#HistoryRecordEntry$EventInformation",
   33     33   
        "com.amazonaws.ec2",
   34     34   
        "HistoryRecordEntry",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::Structure,
   37         -
    "event_information",
          37  +
    "EventInformation",
   38     38   
    0,
   39     39   
)
   40     40   
.with_xml_name("eventInformation");
   41     41   
static HISTORYRECORDENTRY_MEMBER_EVENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.ec2#HistoryRecordEntry$EventType",
   44     44   
        "com.amazonaws.ec2",
   45     45   
        "HistoryRecordEntry",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "event_type",
          48  +
    "EventType",
   49     49   
    1,
   50     50   
)
   51     51   
.with_xml_name("eventType");
   52     52   
static HISTORYRECORDENTRY_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.ec2#HistoryRecordEntry$Timestamp",
   55     55   
        "com.amazonaws.ec2",
   56     56   
        "HistoryRecordEntry",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::Timestamp,
   59         -
    "timestamp",
          59  +
    "Timestamp",
   60     60   
    2,
   61     61   
)
   62     62   
.with_xml_name("timestamp");
   63     63   
static HISTORYRECORDENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    HISTORYRECORDENTRY_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &HISTORYRECORDENTRY_MEMBER_EVENT_INFORMATION,
   68     68   
        &HISTORYRECORDENTRY_MEMBER_EVENT_TYPE,
   69     69   
        &HISTORYRECORDENTRY_MEMBER_TIMESTAMP,
   70     70   
    ],
   71     71   
);
   72     72   
impl HistoryRecordEntry {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HISTORYRECORDENTRY_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for HistoryRecordEntry {
   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.event_information {
   83     83   
            ser.write_struct(&HISTORYRECORDENTRY_MEMBER_EVENT_INFORMATION, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.event_type {
   86     86   
            ser.write_string(&HISTORYRECORDENTRY_MEMBER_EVENT_TYPE, val.as_str())?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.timestamp {
   89     89   
            ser.write_timestamp(&HISTORYRECORDENTRY_MEMBER_TIMESTAMP, val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl HistoryRecordEntry {
   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(&HISTORYRECORDENTRY_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&HISTORYRECORDENTRY_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.event_information = Some(crate::types::EventInformation::deserialize(deser)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.event_type = Some(crate::types::FleetEventType::from(deser.read_string(member)?.as_str()));
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.timestamp = Some(deser.read_timestamp(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl HistoryRecordEntry {
         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 HistoryRecordEntry {
  127    138   
    /// Creates a new builder-style object to manufacture [`HistoryRecordEntry`](crate::types::HistoryRecordEntry).
  128    139   
    pub fn builder() -> crate::types::builders::HistoryRecordEntryBuilder {
  129    140   
        crate::types::builders::HistoryRecordEntryBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`HistoryRecordEntry`](crate::types::HistoryRecordEntry).
  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/_host.rs

@@ -109,109 +302,302 @@
  129    129   
    /// <p>The ID of the Outpost hardware asset on which the Dedicated Host is allocated.</p>
  130    130   
    pub fn asset_id(&self) -> ::std::option::Option<&str> {
  131    131   
        self.asset_id.as_deref()
  132    132   
    }
  133    133   
}
  134    134   
static HOST_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  135    135   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host", "com.amazonaws.ec2", "Host");
  136    136   
static HOST_MEMBER_AUTO_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AutoPlacement", "com.amazonaws.ec2", "Host"),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "auto_placement",
         139  +
    "AutoPlacement",
  140    140   
    0,
  141    141   
)
  142    142   
.with_xml_name("autoPlacement");
  143    143   
static HOST_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AvailabilityZone", "com.amazonaws.ec2", "Host"),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "availability_zone",
         146  +
    "AvailabilityZone",
  147    147   
    1,
  148    148   
)
  149    149   
.with_xml_name("availabilityZone");
  150    150   
static HOST_MEMBER_AVAILABLE_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AvailableCapacity", "com.amazonaws.ec2", "Host"),
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153         -
    "available_capacity",
         153  +
    "AvailableCapacity",
  154    154   
    2,
  155    155   
)
  156    156   
.with_xml_name("availableCapacity");
  157    157   
static HOST_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$ClientToken", "com.amazonaws.ec2", "Host"),
  159    159   
    ::aws_smithy_schema::ShapeType::String,
  160         -
    "client_token",
         160  +
    "ClientToken",
  161    161   
    3,
  162    162   
)
  163    163   
.with_xml_name("clientToken");
  164    164   
static HOST_MEMBER_HOST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$HostId", "com.amazonaws.ec2", "Host"),
  166    166   
    ::aws_smithy_schema::ShapeType::String,
  167         -
    "host_id",
         167  +
    "HostId",
  168    168   
    4,
  169    169   
)
  170    170   
.with_xml_name("hostId");
  171    171   
static HOST_MEMBER_HOST_PROPERTIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$HostProperties", "com.amazonaws.ec2", "Host"),
  173    173   
    ::aws_smithy_schema::ShapeType::Structure,
  174         -
    "host_properties",
         174  +
    "HostProperties",
  175    175   
    5,
  176    176   
)
  177    177   
.with_xml_name("hostProperties");
  178    178   
static HOST_MEMBER_HOST_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$HostReservationId", "com.amazonaws.ec2", "Host"),
  180    180   
    ::aws_smithy_schema::ShapeType::String,
  181         -
    "host_reservation_id",
         181  +
    "HostReservationId",
  182    182   
    6,
  183    183   
)
  184    184   
.with_xml_name("hostReservationId");
  185    185   
static HOST_MEMBER_INSTANCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$Instances", "com.amazonaws.ec2", "Host"),
  187    187   
    ::aws_smithy_schema::ShapeType::List,
  188         -
    "instances",
         188  +
    "Instances",
  189    189   
    7,
  190    190   
)
  191    191   
.with_xml_name("instances");
  192    192   
static HOST_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$State", "com.amazonaws.ec2", "Host"),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "state",
         195  +
    "State",
  196    196   
    8,
  197    197   
)
  198    198   
.with_xml_name("state");
  199    199   
static HOST_MEMBER_ALLOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AllocationTime", "com.amazonaws.ec2", "Host"),
  201    201   
    ::aws_smithy_schema::ShapeType::Timestamp,
  202         -
    "allocation_time",
         202  +
    "AllocationTime",
  203    203   
    9,
  204    204   
)
  205    205   
.with_xml_name("allocationTime");
  206    206   
static HOST_MEMBER_RELEASE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$ReleaseTime", "com.amazonaws.ec2", "Host"),
  208    208   
    ::aws_smithy_schema::ShapeType::Timestamp,
  209         -
    "release_time",
         209  +
    "ReleaseTime",
  210    210   
    10,
  211    211   
)
  212    212   
.with_xml_name("releaseTime");
  213    213   
static HOST_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  214    214   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$Tags", "com.amazonaws.ec2", "Host"),
  215    215   
    ::aws_smithy_schema::ShapeType::List,
  216         -
    "tags",
         216  +
    "Tags",
  217    217   
    11,
  218    218   
)
  219    219   
.with_xml_name("tagSet");
  220    220   
static HOST_MEMBER_HOST_RECOVERY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  221    221   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$HostRecovery", "com.amazonaws.ec2", "Host"),
  222    222   
    ::aws_smithy_schema::ShapeType::String,
  223         -
    "host_recovery",
         223  +
    "HostRecovery",
  224    224   
    12,
  225    225   
)
  226    226   
.with_xml_name("hostRecovery");
  227    227   
static HOST_MEMBER_ALLOWS_MULTIPLE_INSTANCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AllowsMultipleInstanceTypes", "com.amazonaws.ec2", "Host"),
  229    229   
    ::aws_smithy_schema::ShapeType::String,
  230         -
    "allows_multiple_instance_types",
         230  +
    "AllowsMultipleInstanceTypes",
  231    231   
    13,
  232    232   
)
  233    233   
.with_xml_name("allowsMultipleInstanceTypes");
  234    234   
static HOST_MEMBER_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  235    235   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$OwnerId", "com.amazonaws.ec2", "Host"),
  236    236   
    ::aws_smithy_schema::ShapeType::String,
  237         -
    "owner_id",
         237  +
    "OwnerId",
  238    238   
    14,
  239    239   
)
  240    240   
.with_xml_name("ownerId");
  241    241   
static HOST_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  242    242   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AvailabilityZoneId", "com.amazonaws.ec2", "Host"),
  243    243   
    ::aws_smithy_schema::ShapeType::String,
  244         -
    "availability_zone_id",
         244  +
    "AvailabilityZoneId",
  245    245   
    15,
  246    246   
)
  247    247   
.with_xml_name("availabilityZoneId");
  248    248   
static HOST_MEMBER_MEMBER_OF_SERVICE_LINKED_RESOURCE_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$MemberOfServiceLinkedResourceGroup", "com.amazonaws.ec2", "Host"),
  250    250   
    ::aws_smithy_schema::ShapeType::Boolean,
  251         -
    "member_of_service_linked_resource_group",
         251  +
    "MemberOfServiceLinkedResourceGroup",
  252    252   
    16,
  253    253   
)
  254    254   
.with_xml_name("memberOfServiceLinkedResourceGroup");
  255    255   
static HOST_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  256    256   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$OutpostArn", "com.amazonaws.ec2", "Host"),
  257    257   
    ::aws_smithy_schema::ShapeType::String,
  258         -
    "outpost_arn",
         258  +
    "OutpostArn",
  259    259   
    17,
  260    260   
)
  261    261   
.with_xml_name("outpostArn");
  262    262   
static HOST_MEMBER_HOST_MAINTENANCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  263    263   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$HostMaintenance", "com.amazonaws.ec2", "Host"),
  264    264   
    ::aws_smithy_schema::ShapeType::String,
  265         -
    "host_maintenance",
         265  +
    "HostMaintenance",
  266    266   
    18,
  267    267   
)
  268    268   
.with_xml_name("hostMaintenance");
  269    269   
static HOST_MEMBER_ASSET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  270    270   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Host$AssetId", "com.amazonaws.ec2", "Host"),
  271    271   
    ::aws_smithy_schema::ShapeType::String,
  272         -
    "asset_id",
         272  +
    "AssetId",
  273    273   
    19,
  274    274   
)
  275    275   
.with_xml_name("assetId");
  276    276   
static HOST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  277    277   
    HOST_SCHEMA_ID,
  278    278   
    ::aws_smithy_schema::ShapeType::Structure,
  279    279   
    &[
  280    280   
        &HOST_MEMBER_AUTO_PLACEMENT,
  281    281   
        &HOST_MEMBER_AVAILABILITY_ZONE,
  282    282   
        &HOST_MEMBER_AVAILABLE_CAPACITY,
@@ -357,357 +518,523 @@
  377    377   
            ser.write_string(&HOST_MEMBER_HOST_MAINTENANCE, val.as_str())?;
  378    378   
        }
  379    379   
        if let Some(ref val) = self.asset_id {
  380    380   
            ser.write_string(&HOST_MEMBER_ASSET_ID, val)?;
  381    381   
        }
  382    382   
        Ok(())
  383    383   
    }
  384    384   
}
  385    385   
impl Host {
  386    386   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  387         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  388         -
        deserializer: &mut D,
         387  +
    pub fn deserialize(
         388  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  389    389   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  390    390   
        #[allow(unused_variables, unused_mut)]
  391    391   
        let mut builder = Self::builder();
  392    392   
        #[allow(
  393    393   
            unused_variables,
  394    394   
            unreachable_code,
  395    395   
            clippy::single_match,
  396    396   
            clippy::match_single_binding,
  397    397   
            clippy::diverging_sub_expression
  398    398   
        )]
  399         -
        deserializer.read_struct(&HOST_SCHEMA, (), |_, member, deser| {
         399  +
        deserializer.read_struct(&HOST_SCHEMA, &mut |member, deser| {
  400    400   
            match member.member_index() {
  401    401   
                Some(0) => {
  402    402   
                    builder.auto_placement = Some(crate::types::AutoPlacement::from(deser.read_string(member)?.as_str()));
  403    403   
                }
  404    404   
                Some(1) => {
  405    405   
                    builder.availability_zone = Some(deser.read_string(member)?);
  406    406   
                }
  407    407   
                Some(2) => {
  408    408   
                    builder.available_capacity = Some(crate::types::AvailableCapacity::deserialize(deser)?);
  409    409   
                }
  410    410   
                Some(3) => {
  411    411   
                    builder.client_token = Some(deser.read_string(member)?);
  412    412   
                }
  413    413   
                Some(4) => {
  414    414   
                    builder.host_id = Some(deser.read_string(member)?);
  415    415   
                }
  416    416   
                Some(5) => {
  417    417   
                    builder.host_properties = Some(crate::types::HostProperties::deserialize(deser)?);
  418    418   
                }
  419    419   
                Some(6) => {
  420    420   
                    builder.host_reservation_id = Some(deser.read_string(member)?);
  421    421   
                }
  422    422   
                Some(7) => {
  423    423   
                    builder.instances = Some({
  424         -
                        let container = if let Some(cap) = deser.container_size() {
  425         -
                            Vec::with_capacity(cap)
  426         -
                        } else {
  427         -
                            Vec::new()
  428         -
                        };
  429         -
                        deser.read_list(member, container, |mut list, deser| {
  430         -
                            list.push(crate::types::HostInstance::deserialize(deser)?);
  431         -
                            Ok(list)
  432         -
                        })?
         424  +
                        let mut container = Vec::new();
         425  +
                        deser.read_list(member, &mut |deser| {
         426  +
                            container.push(crate::types::HostInstance::deserialize(deser)?);
         427  +
                            Ok(())
         428  +
                        })?;
         429  +
                        container
  433    430   
                    });
  434    431   
                }
  435    432   
                Some(8) => {
  436    433   
                    builder.state = Some(crate::types::AllocationState::from(deser.read_string(member)?.as_str()));
  437    434   
                }
  438    435   
                Some(9) => {
  439    436   
                    builder.allocation_time = Some(deser.read_timestamp(member)?);
  440    437   
                }
  441    438   
                Some(10) => {
  442    439   
                    builder.release_time = Some(deser.read_timestamp(member)?);
  443    440   
                }
  444    441   
                Some(11) => {
  445    442   
                    builder.tags = Some({
  446         -
                        let container = if let Some(cap) = deser.container_size() {
  447         -
                            Vec::with_capacity(cap)
  448         -
                        } else {
  449         -
                            Vec::new()
  450         -
                        };
  451         -
                        deser.read_list(member, container, |mut list, deser| {
  452         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  453         -
                            Ok(list)
  454         -
                        })?
         443  +
                        let mut container = Vec::new();
         444  +
                        deser.read_list(member, &mut |deser| {
         445  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         446  +
                            Ok(())
         447  +
                        })?;
         448  +
                        container
  455    449   
                    });
  456    450   
                }
  457    451   
                Some(12) => {
  458    452   
                    builder.host_recovery = Some(crate::types::HostRecovery::from(deser.read_string(member)?.as_str()));
  459    453   
                }
  460    454   
                Some(13) => {
  461    455   
                    builder.allows_multiple_instance_types =
  462    456   
                        Some(crate::types::AllowsMultipleInstanceTypes::from(deser.read_string(member)?.as_str()));
  463    457   
                }
  464    458   
                Some(14) => {
  465    459   
                    builder.owner_id = Some(deser.read_string(member)?);
  466    460   
                }
  467    461   
                Some(15) => {
  468    462   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  469    463   
                }
  470    464   
                Some(16) => {
  471    465   
                    builder.member_of_service_linked_resource_group = Some(deser.read_boolean(member)?);
  472    466   
                }
  473    467   
                Some(17) => {
  474    468   
                    builder.outpost_arn = Some(deser.read_string(member)?);
  475    469   
                }
  476    470   
                Some(18) => {
  477    471   
                    builder.host_maintenance = Some(crate::types::HostMaintenance::from(deser.read_string(member)?.as_str()));
  478    472   
                }
  479    473   
                Some(19) => {
  480    474   
                    builder.asset_id = Some(deser.read_string(member)?);
  481    475   
                }
  482    476   
                _ => {}
  483    477   
            }
  484    478   
            Ok(())
  485    479   
        })?;
  486    480   
        Ok(builder.build())
  487    481   
    }
  488    482   
}
         483  +
impl Host {
         484  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         485  +
    pub fn deserialize_with_response(
         486  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         487  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         488  +
        _status: u16,
         489  +
        _body: &[u8],
         490  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         491  +
        Self::deserialize(deserializer)
         492  +
    }
         493  +
}
  489    494   
impl Host {
  490    495   
    /// Creates a new builder-style object to manufacture [`Host`](crate::types::Host).
  491    496   
    pub fn builder() -> crate::types::builders::HostBuilder {
  492    497   
        crate::types::builders::HostBuilder::default()
  493    498   
    }
  494    499   
}
  495    500   
  496    501   
/// A builder for [`Host`](crate::types::Host).
  497    502   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  498    503   
#[non_exhaustive]

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

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

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

@@ -27,27 +223,234 @@
   47     47   
    /// <p>The upfront price of the offering. Does not apply to No Upfront offerings.</p>
   48     48   
    pub fn upfront_price(&self) -> ::std::option::Option<&str> {
   49     49   
        self.upfront_price.as_deref()
   50     50   
    }
   51     51   
}
   52     52   
static HOSTOFFERING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   53     53   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering", "com.amazonaws.ec2", "HostOffering");
   54     54   
static HOSTOFFERING_MEMBER_CURRENCY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$CurrencyCode", "com.amazonaws.ec2", "HostOffering"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "currency_code",
          57  +
    "CurrencyCode",
   58     58   
    0,
   59     59   
)
   60     60   
.with_xml_name("currencyCode");
   61     61   
static HOSTOFFERING_MEMBER_DURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$Duration", "com.amazonaws.ec2", "HostOffering"),
   63     63   
    ::aws_smithy_schema::ShapeType::Integer,
   64         -
    "duration",
          64  +
    "Duration",
   65     65   
    1,
   66     66   
)
   67     67   
.with_xml_name("duration");
   68     68   
static HOSTOFFERING_MEMBER_HOURLY_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$HourlyPrice", "com.amazonaws.ec2", "HostOffering"),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "hourly_price",
          71  +
    "HourlyPrice",
   72     72   
    2,
   73     73   
)
   74     74   
.with_xml_name("hourlyPrice");
   75     75   
static HOSTOFFERING_MEMBER_INSTANCE_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$InstanceFamily", "com.amazonaws.ec2", "HostOffering"),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "instance_family",
          78  +
    "InstanceFamily",
   79     79   
    3,
   80     80   
)
   81     81   
.with_xml_name("instanceFamily");
   82     82   
static HOSTOFFERING_MEMBER_OFFERING_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$OfferingId", "com.amazonaws.ec2", "HostOffering"),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "offering_id",
          85  +
    "OfferingId",
   86     86   
    4,
   87     87   
)
   88     88   
.with_xml_name("offeringId");
   89     89   
static HOSTOFFERING_MEMBER_PAYMENT_OPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$PaymentOption", "com.amazonaws.ec2", "HostOffering"),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "payment_option",
          92  +
    "PaymentOption",
   93     93   
    5,
   94     94   
)
   95     95   
.with_xml_name("paymentOption");
   96     96   
static HOSTOFFERING_MEMBER_UPFRONT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostOffering$UpfrontPrice", "com.amazonaws.ec2", "HostOffering"),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "upfront_price",
          99  +
    "UpfrontPrice",
  100    100   
    6,
  101    101   
)
  102    102   
.with_xml_name("upfrontPrice");
  103    103   
static HOSTOFFERING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    HOSTOFFERING_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &HOSTOFFERING_MEMBER_CURRENCY_CODE,
  108    108   
        &HOSTOFFERING_MEMBER_DURATION,
  109    109   
        &HOSTOFFERING_MEMBER_HOURLY_PRICE,
  110    110   
        &HOSTOFFERING_MEMBER_INSTANCE_FAMILY,
  111    111   
        &HOSTOFFERING_MEMBER_OFFERING_ID,
  112    112   
        &HOSTOFFERING_MEMBER_PAYMENT_OPTION,
  113    113   
        &HOSTOFFERING_MEMBER_UPFRONT_PRICE,
  114    114   
    ],
  115    115   
);
  116    116   
impl HostOffering {
  117    117   
    /// The schema for this shape.
  118    118   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HOSTOFFERING_SCHEMA;
  119    119   
}
  120    120   
impl ::aws_smithy_schema::serde::SerializableStruct for HostOffering {
  121    121   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  122    122   
    fn serialize_members(
  123    123   
        &self,
  124    124   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  125    125   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  126    126   
        if let Some(ref val) = self.currency_code {
  127    127   
            ser.write_string(&HOSTOFFERING_MEMBER_CURRENCY_CODE, val.as_str())?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.duration {
  130    130   
            ser.write_integer(&HOSTOFFERING_MEMBER_DURATION, *val)?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.hourly_price {
  133    133   
            ser.write_string(&HOSTOFFERING_MEMBER_HOURLY_PRICE, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.instance_family {
  136    136   
            ser.write_string(&HOSTOFFERING_MEMBER_INSTANCE_FAMILY, val)?;
  137    137   
        }
  138    138   
        if let Some(ref val) = self.offering_id {
  139    139   
            ser.write_string(&HOSTOFFERING_MEMBER_OFFERING_ID, val)?;
  140    140   
        }
  141    141   
        if let Some(ref val) = self.payment_option {
  142    142   
            ser.write_string(&HOSTOFFERING_MEMBER_PAYMENT_OPTION, val.as_str())?;
  143    143   
        }
  144    144   
        if let Some(ref val) = self.upfront_price {
  145    145   
            ser.write_string(&HOSTOFFERING_MEMBER_UPFRONT_PRICE, val)?;
  146    146   
        }
  147    147   
        Ok(())
  148    148   
    }
  149    149   
}
  150    150   
impl HostOffering {
  151    151   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  152         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  153         -
        deserializer: &mut D,
         152  +
    pub fn deserialize(
         153  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  154    154   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  155    155   
        #[allow(unused_variables, unused_mut)]
  156    156   
        let mut builder = Self::builder();
  157    157   
        #[allow(
  158    158   
            unused_variables,
  159    159   
            unreachable_code,
  160    160   
            clippy::single_match,
  161    161   
            clippy::match_single_binding,
  162    162   
            clippy::diverging_sub_expression
  163    163   
        )]
  164         -
        deserializer.read_struct(&HOSTOFFERING_SCHEMA, (), |_, member, deser| {
         164  +
        deserializer.read_struct(&HOSTOFFERING_SCHEMA, &mut |member, deser| {
  165    165   
            match member.member_index() {
  166    166   
                Some(0) => {
  167    167   
                    builder.currency_code = Some(crate::types::CurrencyCodeValues::from(deser.read_string(member)?.as_str()));
  168    168   
                }
  169    169   
                Some(1) => {
  170    170   
                    builder.duration = Some(deser.read_integer(member)?);
  171    171   
                }
  172    172   
                Some(2) => {
  173    173   
                    builder.hourly_price = Some(deser.read_string(member)?);
  174    174   
                }
  175    175   
                Some(3) => {
  176    176   
                    builder.instance_family = Some(deser.read_string(member)?);
  177    177   
                }
  178    178   
                Some(4) => {
  179    179   
                    builder.offering_id = Some(deser.read_string(member)?);
  180    180   
                }
  181    181   
                Some(5) => {
  182    182   
                    builder.payment_option = Some(crate::types::PaymentOption::from(deser.read_string(member)?.as_str()));
  183    183   
                }
  184    184   
                Some(6) => {
  185    185   
                    builder.upfront_price = Some(deser.read_string(member)?);
  186    186   
                }
  187    187   
                _ => {}
  188    188   
            }
  189    189   
            Ok(())
  190    190   
        })?;
  191    191   
        Ok(builder.build())
  192    192   
    }
  193    193   
}
         194  +
impl HostOffering {
         195  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         196  +
    pub fn deserialize_with_response(
         197  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         198  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         199  +
        _status: u16,
         200  +
        _body: &[u8],
         201  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         202  +
        Self::deserialize(deserializer)
         203  +
    }
         204  +
}
  194    205   
impl HostOffering {
  195    206   
    /// Creates a new builder-style object to manufacture [`HostOffering`](crate::types::HostOffering).
  196    207   
    pub fn builder() -> crate::types::builders::HostOfferingBuilder {
  197    208   
        crate::types::builders::HostOfferingBuilder::default()
  198    209   
    }
  199    210   
}
  200    211   
  201    212   
/// A builder for [`HostOffering`](crate::types::HostOffering).
  202    213   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  203    214   
#[non_exhaustive]

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

@@ -15,15 +183,194 @@
   35     35   
    /// <p>The total number of vCPUs on the Dedicated Host.</p>
   36     36   
    pub fn total_v_cpus(&self) -> ::std::option::Option<i32> {
   37     37   
        self.total_v_cpus
   38     38   
    }
   39     39   
}
   40     40   
static HOSTPROPERTIES_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostProperties", "com.amazonaws.ec2", "HostProperties");
   42     42   
static HOSTPROPERTIES_MEMBER_CORES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostProperties$Cores", "com.amazonaws.ec2", "HostProperties"),
   44     44   
    ::aws_smithy_schema::ShapeType::Integer,
   45         -
    "cores",
          45  +
    "Cores",
   46     46   
    0,
   47     47   
)
   48     48   
.with_xml_name("cores");
   49     49   
static HOSTPROPERTIES_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostProperties$InstanceType", "com.amazonaws.ec2", "HostProperties"),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "instance_type",
          52  +
    "InstanceType",
   53     53   
    1,
   54     54   
)
   55     55   
.with_xml_name("instanceType");
   56     56   
static HOSTPROPERTIES_MEMBER_INSTANCE_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostProperties$InstanceFamily", "com.amazonaws.ec2", "HostProperties"),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "instance_family",
          59  +
    "InstanceFamily",
   60     60   
    2,
   61     61   
)
   62     62   
.with_xml_name("instanceFamily");
   63     63   
static HOSTPROPERTIES_MEMBER_SOCKETS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostProperties$Sockets", "com.amazonaws.ec2", "HostProperties"),
   65     65   
    ::aws_smithy_schema::ShapeType::Integer,
   66         -
    "sockets",
          66  +
    "Sockets",
   67     67   
    3,
   68     68   
)
   69     69   
.with_xml_name("sockets");
   70     70   
static HOSTPROPERTIES_MEMBER_TOTAL_V_CPUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostProperties$TotalVCpus", "com.amazonaws.ec2", "HostProperties"),
   72     72   
    ::aws_smithy_schema::ShapeType::Integer,
   73         -
    "total_v_cpus",
          73  +
    "TotalVCpus",
   74     74   
    4,
   75     75   
)
   76     76   
.with_xml_name("totalVCpus");
   77     77   
static HOSTPROPERTIES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   78     78   
    HOSTPROPERTIES_SCHEMA_ID,
   79     79   
    ::aws_smithy_schema::ShapeType::Structure,
   80     80   
    &[
   81     81   
        &HOSTPROPERTIES_MEMBER_CORES,
   82     82   
        &HOSTPROPERTIES_MEMBER_INSTANCE_TYPE,
   83     83   
        &HOSTPROPERTIES_MEMBER_INSTANCE_FAMILY,
   84     84   
        &HOSTPROPERTIES_MEMBER_SOCKETS,
   85     85   
        &HOSTPROPERTIES_MEMBER_TOTAL_V_CPUS,
   86     86   
    ],
   87     87   
);
   88     88   
impl HostProperties {
   89     89   
    /// The schema for this shape.
   90     90   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HOSTPROPERTIES_SCHEMA;
   91     91   
}
   92     92   
impl ::aws_smithy_schema::serde::SerializableStruct for HostProperties {
   93     93   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   94     94   
    fn serialize_members(
   95     95   
        &self,
   96     96   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   97     97   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   98     98   
        if let Some(ref val) = self.cores {
   99     99   
            ser.write_integer(&HOSTPROPERTIES_MEMBER_CORES, *val)?;
  100    100   
        }
  101    101   
        if let Some(ref val) = self.instance_type {
  102    102   
            ser.write_string(&HOSTPROPERTIES_MEMBER_INSTANCE_TYPE, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.instance_family {
  105    105   
            ser.write_string(&HOSTPROPERTIES_MEMBER_INSTANCE_FAMILY, val)?;
  106    106   
        }
  107    107   
        if let Some(ref val) = self.sockets {
  108    108   
            ser.write_integer(&HOSTPROPERTIES_MEMBER_SOCKETS, *val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.total_v_cpus {
  111    111   
            ser.write_integer(&HOSTPROPERTIES_MEMBER_TOTAL_V_CPUS, *val)?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl HostProperties {
  117    117   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        #[allow(unused_variables, unused_mut)]
  122    122   
        let mut builder = Self::builder();
  123    123   
        #[allow(
  124    124   
            unused_variables,
  125    125   
            unreachable_code,
  126    126   
            clippy::single_match,
  127    127   
            clippy::match_single_binding,
  128    128   
            clippy::diverging_sub_expression
  129    129   
        )]
  130         -
        deserializer.read_struct(&HOSTPROPERTIES_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&HOSTPROPERTIES_SCHEMA, &mut |member, deser| {
  131    131   
            match member.member_index() {
  132    132   
                Some(0) => {
  133    133   
                    builder.cores = Some(deser.read_integer(member)?);
  134    134   
                }
  135    135   
                Some(1) => {
  136    136   
                    builder.instance_type = Some(deser.read_string(member)?);
  137    137   
                }
  138    138   
                Some(2) => {
  139    139   
                    builder.instance_family = Some(deser.read_string(member)?);
  140    140   
                }
  141    141   
                Some(3) => {
  142    142   
                    builder.sockets = Some(deser.read_integer(member)?);
  143    143   
                }
  144    144   
                Some(4) => {
  145    145   
                    builder.total_v_cpus = Some(deser.read_integer(member)?);
  146    146   
                }
  147    147   
                _ => {}
  148    148   
            }
  149    149   
            Ok(())
  150    150   
        })?;
  151    151   
        Ok(builder.build())
  152    152   
    }
  153    153   
}
         154  +
impl HostProperties {
         155  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         156  +
    pub fn deserialize_with_response(
         157  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         158  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         159  +
        _status: u16,
         160  +
        _body: &[u8],
         161  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         162  +
        Self::deserialize(deserializer)
         163  +
    }
         164  +
}
  154    165   
impl HostProperties {
  155    166   
    /// Creates a new builder-style object to manufacture [`HostProperties`](crate::types::HostProperties).
  156    167   
    pub fn builder() -> crate::types::builders::HostPropertiesBuilder {
  157    168   
        crate::types::builders::HostPropertiesBuilder::default()
  158    169   
    }
  159    170   
}
  160    171   
  161    172   
/// A builder for [`HostProperties`](crate::types::HostProperties).
  162    173   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  163    174   
#[non_exhaustive]

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

@@ -73,73 +228,228 @@
   93     93   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   94     94   
    pub fn tags(&self) -> &[crate::types::Tag] {
   95     95   
        self.tags.as_deref().unwrap_or_default()
   96     96   
    }
   97     97   
}
   98     98   
static HOSTRESERVATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation", "com.amazonaws.ec2", "HostReservation");
  100    100   
static HOSTRESERVATION_MEMBER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$Count", "com.amazonaws.ec2", "HostReservation"),
  102    102   
    ::aws_smithy_schema::ShapeType::Integer,
  103         -
    "count",
         103  +
    "Count",
  104    104   
    0,
  105    105   
)
  106    106   
.with_xml_name("count");
  107    107   
static HOSTRESERVATION_MEMBER_CURRENCY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$CurrencyCode", "com.amazonaws.ec2", "HostReservation"),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "currency_code",
         110  +
    "CurrencyCode",
  111    111   
    1,
  112    112   
)
  113    113   
.with_xml_name("currencyCode");
  114    114   
static HOSTRESERVATION_MEMBER_DURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$Duration", "com.amazonaws.ec2", "HostReservation"),
  116    116   
    ::aws_smithy_schema::ShapeType::Integer,
  117         -
    "duration",
         117  +
    "Duration",
  118    118   
    2,
  119    119   
)
  120    120   
.with_xml_name("duration");
  121    121   
static HOSTRESERVATION_MEMBER_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$End", "com.amazonaws.ec2", "HostReservation"),
  123    123   
    ::aws_smithy_schema::ShapeType::Timestamp,
  124         -
    "end",
         124  +
    "End",
  125    125   
    3,
  126    126   
)
  127    127   
.with_xml_name("end");
  128    128   
static HOSTRESERVATION_MEMBER_HOST_ID_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$HostIdSet", "com.amazonaws.ec2", "HostReservation"),
  130    130   
    ::aws_smithy_schema::ShapeType::List,
  131         -
    "host_id_set",
         131  +
    "HostIdSet",
  132    132   
    4,
  133    133   
)
  134    134   
.with_xml_name("hostIdSet");
  135    135   
static HOSTRESERVATION_MEMBER_HOST_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.ec2#HostReservation$HostReservationId",
  138    138   
        "com.amazonaws.ec2",
  139    139   
        "HostReservation",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "host_reservation_id",
         142  +
    "HostReservationId",
  143    143   
    5,
  144    144   
)
  145    145   
.with_xml_name("hostReservationId");
  146    146   
static HOSTRESERVATION_MEMBER_HOURLY_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$HourlyPrice", "com.amazonaws.ec2", "HostReservation"),
  148    148   
    ::aws_smithy_schema::ShapeType::String,
  149         -
    "hourly_price",
         149  +
    "HourlyPrice",
  150    150   
    6,
  151    151   
)
  152    152   
.with_xml_name("hourlyPrice");
  153    153   
static HOSTRESERVATION_MEMBER_INSTANCE_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  154    154   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$InstanceFamily", "com.amazonaws.ec2", "HostReservation"),
  155    155   
    ::aws_smithy_schema::ShapeType::String,
  156         -
    "instance_family",
         156  +
    "InstanceFamily",
  157    157   
    7,
  158    158   
)
  159    159   
.with_xml_name("instanceFamily");
  160    160   
static HOSTRESERVATION_MEMBER_OFFERING_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$OfferingId", "com.amazonaws.ec2", "HostReservation"),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "offering_id",
         163  +
    "OfferingId",
  164    164   
    8,
  165    165   
)
  166    166   
.with_xml_name("offeringId");
  167    167   
static HOSTRESERVATION_MEMBER_PAYMENT_OPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$PaymentOption", "com.amazonaws.ec2", "HostReservation"),
  169    169   
    ::aws_smithy_schema::ShapeType::String,
  170         -
    "payment_option",
         170  +
    "PaymentOption",
  171    171   
    9,
  172    172   
)
  173    173   
.with_xml_name("paymentOption");
  174    174   
static HOSTRESERVATION_MEMBER_START: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$Start", "com.amazonaws.ec2", "HostReservation"),
  176    176   
    ::aws_smithy_schema::ShapeType::Timestamp,
  177         -
    "start",
         177  +
    "Start",
  178    178   
    10,
  179    179   
)
  180    180   
.with_xml_name("start");
  181    181   
static HOSTRESERVATION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  182    182   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$State", "com.amazonaws.ec2", "HostReservation"),
  183    183   
    ::aws_smithy_schema::ShapeType::String,
  184         -
    "state",
         184  +
    "State",
  185    185   
    11,
  186    186   
)
  187    187   
.with_xml_name("state");
  188    188   
static HOSTRESERVATION_MEMBER_UPFRONT_PRICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$UpfrontPrice", "com.amazonaws.ec2", "HostReservation"),
  190    190   
    ::aws_smithy_schema::ShapeType::String,
  191         -
    "upfront_price",
         191  +
    "UpfrontPrice",
  192    192   
    12,
  193    193   
)
  194    194   
.with_xml_name("upfrontPrice");
  195    195   
static HOSTRESERVATION_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#HostReservation$Tags", "com.amazonaws.ec2", "HostReservation"),
  197    197   
    ::aws_smithy_schema::ShapeType::List,
  198         -
    "tags",
         198  +
    "Tags",
  199    199   
    13,
  200    200   
)
  201    201   
.with_xml_name("tagSet");
  202    202   
static HOSTRESERVATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  203    203   
    HOSTRESERVATION_SCHEMA_ID,
  204    204   
    ::aws_smithy_schema::ShapeType::Structure,
  205    205   
    &[
  206    206   
        &HOSTRESERVATION_MEMBER_COUNT,
  207    207   
        &HOSTRESERVATION_MEMBER_CURRENCY_CODE,
  208    208   
        &HOSTRESERVATION_MEMBER_DURATION,
@@ -265,265 +407,405 @@
  285    285   
                    }
  286    286   
                    Ok(())
  287    287   
                },
  288    288   
            )?;
  289    289   
        }
  290    290   
        Ok(())
  291    291   
    }
  292    292   
}
  293    293   
impl HostReservation {
  294    294   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  295         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  296         -
        deserializer: &mut D,
         295  +
    pub fn deserialize(
         296  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  297    297   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  298    298   
        #[allow(unused_variables, unused_mut)]
  299    299   
        let mut builder = Self::builder();
  300    300   
        #[allow(
  301    301   
            unused_variables,
  302    302   
            unreachable_code,
  303    303   
            clippy::single_match,
  304    304   
            clippy::match_single_binding,
  305    305   
            clippy::diverging_sub_expression
  306    306   
        )]
  307         -
        deserializer.read_struct(&HOSTRESERVATION_SCHEMA, (), |_, member, deser| {
         307  +
        deserializer.read_struct(&HOSTRESERVATION_SCHEMA, &mut |member, deser| {
  308    308   
            match member.member_index() {
  309    309   
                Some(0) => {
  310    310   
                    builder.count = Some(deser.read_integer(member)?);
  311    311   
                }
  312    312   
                Some(1) => {
  313    313   
                    builder.currency_code = Some(crate::types::CurrencyCodeValues::from(deser.read_string(member)?.as_str()));
  314    314   
                }
  315    315   
                Some(2) => {
  316    316   
                    builder.duration = Some(deser.read_integer(member)?);
  317    317   
                }
  318    318   
                Some(3) => {
  319    319   
                    builder.end = Some(deser.read_timestamp(member)?);
  320    320   
                }
  321    321   
                Some(4) => {
  322         -
                    builder.host_id_set = Some({
  323         -
                        let container = if let Some(cap) = deser.container_size() {
  324         -
                            Vec::with_capacity(cap)
  325         -
                        } else {
  326         -
                            Vec::new()
  327         -
                        };
  328         -
                        deser.read_list(member, container, |mut list, deser| {
  329         -
                            list.push(deser.read_string(member)?);
  330         -
                            Ok(list)
  331         -
                        })?
  332         -
                    });
         322  +
                    builder.host_id_set = Some(deser.read_string_list(member)?);
  333    323   
                }
  334    324   
                Some(5) => {
  335    325   
                    builder.host_reservation_id = Some(deser.read_string(member)?);
  336    326   
                }
  337    327   
                Some(6) => {
  338    328   
                    builder.hourly_price = Some(deser.read_string(member)?);
  339    329   
                }
  340    330   
                Some(7) => {
  341    331   
                    builder.instance_family = Some(deser.read_string(member)?);
  342    332   
                }
  343    333   
                Some(8) => {
  344    334   
                    builder.offering_id = Some(deser.read_string(member)?);
  345    335   
                }
  346    336   
                Some(9) => {
  347    337   
                    builder.payment_option = Some(crate::types::PaymentOption::from(deser.read_string(member)?.as_str()));
  348    338   
                }
  349    339   
                Some(10) => {
  350    340   
                    builder.start = Some(deser.read_timestamp(member)?);
  351    341   
                }
  352    342   
                Some(11) => {
  353    343   
                    builder.state = Some(crate::types::ReservationState::from(deser.read_string(member)?.as_str()));
  354    344   
                }
  355    345   
                Some(12) => {
  356    346   
                    builder.upfront_price = Some(deser.read_string(member)?);
  357    347   
                }
  358    348   
                Some(13) => {
  359    349   
                    builder.tags = Some({
  360         -
                        let container = if let Some(cap) = deser.container_size() {
  361         -
                            Vec::with_capacity(cap)
  362         -
                        } else {
  363         -
                            Vec::new()
  364         -
                        };
  365         -
                        deser.read_list(member, container, |mut list, deser| {
  366         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  367         -
                            Ok(list)
  368         -
                        })?
         350  +
                        let mut container = Vec::new();
         351  +
                        deser.read_list(member, &mut |deser| {
         352  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         353  +
                            Ok(())
         354  +
                        })?;
         355  +
                        container
  369    356   
                    });
  370    357   
                }
  371    358   
                _ => {}
  372    359   
            }
  373    360   
            Ok(())
  374    361   
        })?;
  375    362   
        Ok(builder.build())
  376    363   
    }
  377    364   
}
         365  +
impl HostReservation {
         366  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         367  +
    pub fn deserialize_with_response(
         368  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         369  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         370  +
        _status: u16,
         371  +
        _body: &[u8],
         372  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         373  +
        Self::deserialize(deserializer)
         374  +
    }
         375  +
}
  378    376   
impl HostReservation {
  379    377   
    /// Creates a new builder-style object to manufacture [`HostReservation`](crate::types::HostReservation).
  380    378   
    pub fn builder() -> crate::types::builders::HostReservationBuilder {
  381    379   
        crate::types::builders::HostReservationBuilder::default()
  382    380   
    }
  383    381   
}
  384    382   
  385    383   
/// A builder for [`HostReservation`](crate::types::HostReservation).
  386    384   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  387    385   
#[non_exhaustive]

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

@@ -1,1 +120,131 @@
   17     17   
    /// <p>The ID of the instance profile.</p>
   18     18   
    pub fn id(&self) -> ::std::option::Option<&str> {
   19     19   
        self.id.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static IAMINSTANCEPROFILE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IamInstanceProfile", "com.amazonaws.ec2", "IamInstanceProfile");
   24     24   
static IAMINSTANCEPROFILE_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IamInstanceProfile$Arn", "com.amazonaws.ec2", "IamInstanceProfile"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "arn",
          27  +
    "Arn",
   28     28   
    0,
   29     29   
)
   30     30   
.with_xml_name("arn");
   31     31   
static IAMINSTANCEPROFILE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#IamInstanceProfile$Id", "com.amazonaws.ec2", "IamInstanceProfile"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "id",
          34  +
    "Id",
   35     35   
    1,
   36     36   
)
   37     37   
.with_xml_name("id");
   38     38   
static IAMINSTANCEPROFILE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    IAMINSTANCEPROFILE_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&IAMINSTANCEPROFILE_MEMBER_ARN, &IAMINSTANCEPROFILE_MEMBER_ID],
   42     42   
);
   43     43   
impl IamInstanceProfile {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IAMINSTANCEPROFILE_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for IamInstanceProfile {
   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.arn {
   54     54   
            ser.write_string(&IAMINSTANCEPROFILE_MEMBER_ARN, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.id {
   57     57   
            ser.write_string(&IAMINSTANCEPROFILE_MEMBER_ID, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl IamInstanceProfile {
   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(&IAMINSTANCEPROFILE_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&IAMINSTANCEPROFILE_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.arn = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.id = 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 IamInstanceProfile {
          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 IamInstanceProfile {
   92    103   
    /// Creates a new builder-style object to manufacture [`IamInstanceProfile`](crate::types::IamInstanceProfile).
   93    104   
    pub fn builder() -> crate::types::builders::IamInstanceProfileBuilder {
   94    105   
        crate::types::builders::IamInstanceProfileBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`IamInstanceProfile`](crate::types::IamInstanceProfile).
   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/_iam_instance_profile_association.rs

@@ -22,22 +208,219 @@
   42     42   
    "com.amazonaws.ec2",
   43     43   
    "IamInstanceProfileAssociation",
   44     44   
);
   45     45   
static IAMINSTANCEPROFILEASSOCIATION_MEMBER_ASSOCIATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.ec2#IamInstanceProfileAssociation$AssociationId",
   48     48   
        "com.amazonaws.ec2",
   49     49   
        "IamInstanceProfileAssociation",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "association_id",
          52  +
    "AssociationId",
   53     53   
    0,
   54     54   
)
   55     55   
.with_xml_name("associationId");
   56     56   
static IAMINSTANCEPROFILEASSOCIATION_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.ec2#IamInstanceProfileAssociation$InstanceId",
   59     59   
        "com.amazonaws.ec2",
   60     60   
        "IamInstanceProfileAssociation",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "instance_id",
          63  +
    "InstanceId",
   64     64   
    1,
   65     65   
)
   66     66   
.with_xml_name("instanceId");
   67     67   
static IAMINSTANCEPROFILEASSOCIATION_MEMBER_IAM_INSTANCE_PROFILE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.ec2#IamInstanceProfileAssociation$IamInstanceProfile",
   70     70   
        "com.amazonaws.ec2",
   71     71   
        "IamInstanceProfileAssociation",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Structure,
   74         -
    "iam_instance_profile",
          74  +
    "IamInstanceProfile",
   75     75   
    2,
   76     76   
)
   77     77   
.with_xml_name("iamInstanceProfile");
   78     78   
static IAMINSTANCEPROFILEASSOCIATION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2#IamInstanceProfileAssociation$State",
   81     81   
        "com.amazonaws.ec2",
   82     82   
        "IamInstanceProfileAssociation",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "state",
          85  +
    "State",
   86     86   
    3,
   87     87   
)
   88     88   
.with_xml_name("state");
   89     89   
static IAMINSTANCEPROFILEASSOCIATION_MEMBER_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2#IamInstanceProfileAssociation$Timestamp",
   92     92   
        "com.amazonaws.ec2",
   93     93   
        "IamInstanceProfileAssociation",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Timestamp,
   96         -
    "timestamp",
          96  +
    "Timestamp",
   97     97   
    4,
   98     98   
)
   99     99   
.with_xml_name("timestamp");
  100    100   
static IAMINSTANCEPROFILEASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  101    101   
    IAMINSTANCEPROFILEASSOCIATION_SCHEMA_ID,
  102    102   
    ::aws_smithy_schema::ShapeType::Structure,
  103    103   
    &[
  104    104   
        &IAMINSTANCEPROFILEASSOCIATION_MEMBER_ASSOCIATION_ID,
  105    105   
        &IAMINSTANCEPROFILEASSOCIATION_MEMBER_INSTANCE_ID,
  106    106   
        &IAMINSTANCEPROFILEASSOCIATION_MEMBER_IAM_INSTANCE_PROFILE,
  107    107   
        &IAMINSTANCEPROFILEASSOCIATION_MEMBER_STATE,
  108    108   
        &IAMINSTANCEPROFILEASSOCIATION_MEMBER_TIMESTAMP,
  109    109   
    ],
  110    110   
);
  111    111   
impl IamInstanceProfileAssociation {
  112    112   
    /// The schema for this shape.
  113    113   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IAMINSTANCEPROFILEASSOCIATION_SCHEMA;
  114    114   
}
  115    115   
impl ::aws_smithy_schema::serde::SerializableStruct for IamInstanceProfileAssociation {
  116    116   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  117    117   
    fn serialize_members(
  118    118   
        &self,
  119    119   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  120    120   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        if let Some(ref val) = self.association_id {
  122    122   
            ser.write_string(&IAMINSTANCEPROFILEASSOCIATION_MEMBER_ASSOCIATION_ID, val)?;
  123    123   
        }
  124    124   
        if let Some(ref val) = self.instance_id {
  125    125   
            ser.write_string(&IAMINSTANCEPROFILEASSOCIATION_MEMBER_INSTANCE_ID, val)?;
  126    126   
        }
  127    127   
        if let Some(ref val) = self.iam_instance_profile {
  128    128   
            ser.write_struct(&IAMINSTANCEPROFILEASSOCIATION_MEMBER_IAM_INSTANCE_PROFILE, val)?;
  129    129   
        }
  130    130   
        if let Some(ref val) = self.state {
  131    131   
            ser.write_string(&IAMINSTANCEPROFILEASSOCIATION_MEMBER_STATE, val.as_str())?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.timestamp {
  134    134   
            ser.write_timestamp(&IAMINSTANCEPROFILEASSOCIATION_MEMBER_TIMESTAMP, val)?;
  135    135   
        }
  136    136   
        Ok(())
  137    137   
    }
  138    138   
}
  139    139   
impl IamInstanceProfileAssociation {
  140    140   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  141         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  142         -
        deserializer: &mut D,
         141  +
    pub fn deserialize(
         142  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  143    143   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  144    144   
        #[allow(unused_variables, unused_mut)]
  145    145   
        let mut builder = Self::builder();
  146    146   
        #[allow(
  147    147   
            unused_variables,
  148    148   
            unreachable_code,
  149    149   
            clippy::single_match,
  150    150   
            clippy::match_single_binding,
  151    151   
            clippy::diverging_sub_expression
  152    152   
        )]
  153         -
        deserializer.read_struct(&IAMINSTANCEPROFILEASSOCIATION_SCHEMA, (), |_, member, deser| {
         153  +
        deserializer.read_struct(&IAMINSTANCEPROFILEASSOCIATION_SCHEMA, &mut |member, deser| {
  154    154   
            match member.member_index() {
  155    155   
                Some(0) => {
  156    156   
                    builder.association_id = Some(deser.read_string(member)?);
  157    157   
                }
  158    158   
                Some(1) => {
  159    159   
                    builder.instance_id = Some(deser.read_string(member)?);
  160    160   
                }
  161    161   
                Some(2) => {
  162    162   
                    builder.iam_instance_profile = Some(crate::types::IamInstanceProfile::deserialize(deser)?);
  163    163   
                }
  164    164   
                Some(3) => {
  165    165   
                    builder.state = Some(crate::types::IamInstanceProfileAssociationState::from(
  166    166   
                        deser.read_string(member)?.as_str(),
  167    167   
                    ));
  168    168   
                }
  169    169   
                Some(4) => {
  170    170   
                    builder.timestamp = Some(deser.read_timestamp(member)?);
  171    171   
                }
  172    172   
                _ => {}
  173    173   
            }
  174    174   
            Ok(())
  175    175   
        })?;
  176    176   
        Ok(builder.build())
  177    177   
    }
  178    178   
}
         179  +
impl IamInstanceProfileAssociation {
         180  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         181  +
    pub fn deserialize_with_response(
         182  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         183  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         184  +
        _status: u16,
         185  +
        _body: &[u8],
         186  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         187  +
        Self::deserialize(deserializer)
         188  +
    }
         189  +
}
  179    190   
impl IamInstanceProfileAssociation {
  180    191   
    /// Creates a new builder-style object to manufacture [`IamInstanceProfileAssociation`](crate::types::IamInstanceProfileAssociation).
  181    192   
    pub fn builder() -> crate::types::builders::IamInstanceProfileAssociationBuilder {
  182    193   
        crate::types::builders::IamInstanceProfileAssociationBuilder::default()
  183    194   
    }
  184    195   
}
  185    196   
  186    197   
/// A builder for [`IamInstanceProfileAssociation`](crate::types::IamInstanceProfileAssociation).
  187    198   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  188    199   
#[non_exhaustive]

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

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