AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

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

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

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

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

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

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

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

@@ -97,97 +277,277 @@
  117    117   
    /// <p>The boot mode of the virtual machine.</p>
  118    118   
    pub fn boot_mode(&self) -> ::std::option::Option<&crate::types::BootModeValues> {
  119    119   
        self.boot_mode.as_ref()
  120    120   
    }
  121    121   
}
  122    122   
static IMPORTIMAGETASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  123    123   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask", "com.amazonaws.ec2", "ImportImageTask");
  124    124   
static IMPORTIMAGETASK_MEMBER_ARCHITECTURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Architecture", "com.amazonaws.ec2", "ImportImageTask"),
  126    126   
    ::aws_smithy_schema::ShapeType::String,
  127         -
    "architecture",
         127  +
    "Architecture",
  128    128   
    0,
  129    129   
)
  130    130   
.with_xml_name("architecture");
  131    131   
static IMPORTIMAGETASK_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Description", "com.amazonaws.ec2", "ImportImageTask"),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "description",
         134  +
    "Description",
  135    135   
    1,
  136    136   
)
  137    137   
.with_xml_name("description");
  138    138   
static IMPORTIMAGETASK_MEMBER_ENCRYPTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Encrypted", "com.amazonaws.ec2", "ImportImageTask"),
  140    140   
    ::aws_smithy_schema::ShapeType::Boolean,
  141         -
    "encrypted",
         141  +
    "Encrypted",
  142    142   
    2,
  143    143   
)
  144    144   
.with_xml_name("encrypted");
  145    145   
static IMPORTIMAGETASK_MEMBER_HYPERVISOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Hypervisor", "com.amazonaws.ec2", "ImportImageTask"),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "hypervisor",
         148  +
    "Hypervisor",
  149    149   
    3,
  150    150   
)
  151    151   
.with_xml_name("hypervisor");
  152    152   
static IMPORTIMAGETASK_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$ImageId", "com.amazonaws.ec2", "ImportImageTask"),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "image_id",
         155  +
    "ImageId",
  156    156   
    4,
  157    157   
)
  158    158   
.with_xml_name("imageId");
  159    159   
static IMPORTIMAGETASK_MEMBER_IMPORT_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$ImportTaskId", "com.amazonaws.ec2", "ImportImageTask"),
  161    161   
    ::aws_smithy_schema::ShapeType::String,
  162         -
    "import_task_id",
         162  +
    "ImportTaskId",
  163    163   
    5,
  164    164   
)
  165    165   
.with_xml_name("importTaskId");
  166    166   
static IMPORTIMAGETASK_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$KmsKeyId", "com.amazonaws.ec2", "ImportImageTask"),
  168    168   
    ::aws_smithy_schema::ShapeType::String,
  169         -
    "kms_key_id",
         169  +
    "KmsKeyId",
  170    170   
    6,
  171    171   
)
  172    172   
.with_xml_name("kmsKeyId");
  173    173   
static IMPORTIMAGETASK_MEMBER_LICENSE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$LicenseType", "com.amazonaws.ec2", "ImportImageTask"),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "license_type",
         176  +
    "LicenseType",
  177    177   
    7,
  178    178   
)
  179    179   
.with_xml_name("licenseType");
  180    180   
static IMPORTIMAGETASK_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  181    181   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Platform", "com.amazonaws.ec2", "ImportImageTask"),
  182    182   
    ::aws_smithy_schema::ShapeType::String,
  183         -
    "platform",
         183  +
    "Platform",
  184    184   
    8,
  185    185   
)
  186    186   
.with_xml_name("platform");
  187    187   
static IMPORTIMAGETASK_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  188    188   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Progress", "com.amazonaws.ec2", "ImportImageTask"),
  189    189   
    ::aws_smithy_schema::ShapeType::String,
  190         -
    "progress",
         190  +
    "Progress",
  191    191   
    9,
  192    192   
)
  193    193   
.with_xml_name("progress");
  194    194   
static IMPORTIMAGETASK_MEMBER_SNAPSHOT_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "com.amazonaws.ec2#ImportImageTask$SnapshotDetails",
  197    197   
        "com.amazonaws.ec2",
  198    198   
        "ImportImageTask",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::List,
  201         -
    "snapshot_details",
         201  +
    "SnapshotDetails",
  202    202   
    10,
  203    203   
)
  204    204   
.with_xml_name("snapshotDetailSet");
  205    205   
static IMPORTIMAGETASK_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  206    206   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Status", "com.amazonaws.ec2", "ImportImageTask"),
  207    207   
    ::aws_smithy_schema::ShapeType::String,
  208         -
    "status",
         208  +
    "Status",
  209    209   
    11,
  210    210   
)
  211    211   
.with_xml_name("status");
  212    212   
static IMPORTIMAGETASK_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  213    213   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$StatusMessage", "com.amazonaws.ec2", "ImportImageTask"),
  214    214   
    ::aws_smithy_schema::ShapeType::String,
  215         -
    "status_message",
         215  +
    "StatusMessage",
  216    216   
    12,
  217    217   
)
  218    218   
.with_xml_name("statusMessage");
  219    219   
static IMPORTIMAGETASK_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$Tags", "com.amazonaws.ec2", "ImportImageTask"),
  221    221   
    ::aws_smithy_schema::ShapeType::List,
  222         -
    "tags",
         222  +
    "Tags",
  223    223   
    13,
  224    224   
)
  225    225   
.with_xml_name("tagSet");
  226    226   
static IMPORTIMAGETASK_MEMBER_LICENSE_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static(
  228    228   
        "com.amazonaws.ec2#ImportImageTask$LicenseSpecifications",
  229    229   
        "com.amazonaws.ec2",
  230    230   
        "ImportImageTask",
  231    231   
    ),
  232    232   
    ::aws_smithy_schema::ShapeType::List,
  233         -
    "license_specifications",
         233  +
    "LicenseSpecifications",
  234    234   
    14,
  235    235   
)
  236    236   
.with_xml_name("licenseSpecifications");
  237    237   
static IMPORTIMAGETASK_MEMBER_USAGE_OPERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  238    238   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$UsageOperation", "com.amazonaws.ec2", "ImportImageTask"),
  239    239   
    ::aws_smithy_schema::ShapeType::String,
  240         -
    "usage_operation",
         240  +
    "UsageOperation",
  241    241   
    15,
  242    242   
)
  243    243   
.with_xml_name("usageOperation");
  244    244   
static IMPORTIMAGETASK_MEMBER_BOOT_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  245    245   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportImageTask$BootMode", "com.amazonaws.ec2", "ImportImageTask"),
  246    246   
    ::aws_smithy_schema::ShapeType::String,
  247         -
    "boot_mode",
         247  +
    "BootMode",
  248    248   
    16,
  249    249   
)
  250    250   
.with_xml_name("bootMode");
  251    251   
static IMPORTIMAGETASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  252    252   
    IMPORTIMAGETASK_SCHEMA_ID,
  253    253   
    ::aws_smithy_schema::ShapeType::Structure,
  254    254   
    &[
  255    255   
        &IMPORTIMAGETASK_MEMBER_ARCHITECTURE,
  256    256   
        &IMPORTIMAGETASK_MEMBER_DESCRIPTION,
  257    257   
        &IMPORTIMAGETASK_MEMBER_ENCRYPTED,
@@ -334,334 +495,497 @@
  354    354   
            ser.write_string(&IMPORTIMAGETASK_MEMBER_USAGE_OPERATION, val)?;
  355    355   
        }
  356    356   
        if let Some(ref val) = self.boot_mode {
  357    357   
            ser.write_string(&IMPORTIMAGETASK_MEMBER_BOOT_MODE, val.as_str())?;
  358    358   
        }
  359    359   
        Ok(())
  360    360   
    }
  361    361   
}
  362    362   
impl ImportImageTask {
  363    363   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  364         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  365         -
        deserializer: &mut D,
         364  +
    pub fn deserialize(
         365  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  366    366   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  367    367   
        #[allow(unused_variables, unused_mut)]
  368    368   
        let mut builder = Self::builder();
  369    369   
        #[allow(
  370    370   
            unused_variables,
  371    371   
            unreachable_code,
  372    372   
            clippy::single_match,
  373    373   
            clippy::match_single_binding,
  374    374   
            clippy::diverging_sub_expression
  375    375   
        )]
  376         -
        deserializer.read_struct(&IMPORTIMAGETASK_SCHEMA, (), |_, member, deser| {
         376  +
        deserializer.read_struct(&IMPORTIMAGETASK_SCHEMA, &mut |member, deser| {
  377    377   
            match member.member_index() {
  378    378   
                Some(0) => {
  379    379   
                    builder.architecture = Some(deser.read_string(member)?);
  380    380   
                }
  381    381   
                Some(1) => {
  382    382   
                    builder.description = Some(deser.read_string(member)?);
  383    383   
                }
  384    384   
                Some(2) => {
  385    385   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  386    386   
                }
  387    387   
                Some(3) => {
  388    388   
                    builder.hypervisor = Some(deser.read_string(member)?);
  389    389   
                }
  390    390   
                Some(4) => {
  391    391   
                    builder.image_id = Some(deser.read_string(member)?);
  392    392   
                }
  393    393   
                Some(5) => {
  394    394   
                    builder.import_task_id = Some(deser.read_string(member)?);
  395    395   
                }
  396    396   
                Some(6) => {
  397    397   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  398    398   
                }
  399    399   
                Some(7) => {
  400    400   
                    builder.license_type = Some(deser.read_string(member)?);
  401    401   
                }
  402    402   
                Some(8) => {
  403    403   
                    builder.platform = Some(deser.read_string(member)?);
  404    404   
                }
  405    405   
                Some(9) => {
  406    406   
                    builder.progress = Some(deser.read_string(member)?);
  407    407   
                }
  408    408   
                Some(10) => {
  409    409   
                    builder.snapshot_details = Some({
  410         -
                        let container = if let Some(cap) = deser.container_size() {
  411         -
                            Vec::with_capacity(cap)
  412         -
                        } else {
  413         -
                            Vec::new()
  414         -
                        };
  415         -
                        deser.read_list(member, container, |mut list, deser| {
  416         -
                            list.push(crate::types::SnapshotDetail::deserialize(deser)?);
  417         -
                            Ok(list)
  418         -
                        })?
         410  +
                        let mut container = Vec::new();
         411  +
                        deser.read_list(member, &mut |deser| {
         412  +
                            container.push(crate::types::SnapshotDetail::deserialize(deser)?);
         413  +
                            Ok(())
         414  +
                        })?;
         415  +
                        container
  419    416   
                    });
  420    417   
                }
  421    418   
                Some(11) => {
  422    419   
                    builder.status = Some(deser.read_string(member)?);
  423    420   
                }
  424    421   
                Some(12) => {
  425    422   
                    builder.status_message = Some(deser.read_string(member)?);
  426    423   
                }
  427    424   
                Some(13) => {
  428    425   
                    builder.tags = Some({
  429         -
                        let container = if let Some(cap) = deser.container_size() {
  430         -
                            Vec::with_capacity(cap)
  431         -
                        } else {
  432         -
                            Vec::new()
  433         -
                        };
  434         -
                        deser.read_list(member, container, |mut list, deser| {
  435         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  436         -
                            Ok(list)
  437         -
                        })?
         426  +
                        let mut container = Vec::new();
         427  +
                        deser.read_list(member, &mut |deser| {
         428  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         429  +
                            Ok(())
         430  +
                        })?;
         431  +
                        container
  438    432   
                    });
  439    433   
                }
  440    434   
                Some(14) => {
  441    435   
                    builder.license_specifications = Some({
  442         -
                        let container = if let Some(cap) = deser.container_size() {
  443         -
                            Vec::with_capacity(cap)
  444         -
                        } else {
  445         -
                            Vec::new()
  446         -
                        };
  447         -
                        deser.read_list(member, container, |mut list, deser| {
  448         -
                            list.push(crate::types::ImportImageLicenseConfigurationResponse::deserialize(deser)?);
  449         -
                            Ok(list)
  450         -
                        })?
         436  +
                        let mut container = Vec::new();
         437  +
                        deser.read_list(member, &mut |deser| {
         438  +
                            container.push(crate::types::ImportImageLicenseConfigurationResponse::deserialize(deser)?);
         439  +
                            Ok(())
         440  +
                        })?;
         441  +
                        container
  451    442   
                    });
  452    443   
                }
  453    444   
                Some(15) => {
  454    445   
                    builder.usage_operation = Some(deser.read_string(member)?);
  455    446   
                }
  456    447   
                Some(16) => {
  457    448   
                    builder.boot_mode = Some(crate::types::BootModeValues::from(deser.read_string(member)?.as_str()));
  458    449   
                }
  459    450   
                _ => {}
  460    451   
            }
  461    452   
            Ok(())
  462    453   
        })?;
  463    454   
        Ok(builder.build())
  464    455   
    }
  465    456   
}
         457  +
impl ImportImageTask {
         458  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         459  +
    pub fn deserialize_with_response(
         460  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         461  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         462  +
        _status: u16,
         463  +
        _body: &[u8],
         464  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         465  +
        Self::deserialize(deserializer)
         466  +
    }
         467  +
}
  466    468   
impl ImportImageTask {
  467    469   
    /// Creates a new builder-style object to manufacture [`ImportImageTask`](crate::types::ImportImageTask).
  468    470   
    pub fn builder() -> crate::types::builders::ImportImageTaskBuilder {
  469    471   
        crate::types::builders::ImportImageTaskBuilder::default()
  470    472   
    }
  471    473   
}
  472    474   
  473    475   
/// A builder for [`ImportImageTask`](crate::types::ImportImageTask).
  474    476   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  475    477   
#[non_exhaustive]

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

@@ -79,79 +250,250 @@
   99     99   
    "com.amazonaws.ec2",
  100    100   
    "ImportInstanceLaunchSpecification",
  101    101   
);
  102    102   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_ARCHITECTURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$Architecture",
  105    105   
        "com.amazonaws.ec2",
  106    106   
        "ImportInstanceLaunchSpecification",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "architecture",
         109  +
    "Architecture",
  110    110   
    0,
  111    111   
)
  112    112   
.with_xml_name("architecture");
  113    113   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_GROUP_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$GroupNames",
  116    116   
        "com.amazonaws.ec2",
  117    117   
        "ImportInstanceLaunchSpecification",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::List,
  120         -
    "group_names",
         120  +
    "GroupNames",
  121    121   
    1,
  122    122   
)
  123    123   
.with_xml_name("GroupName");
  124    124   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$GroupIds",
  127    127   
        "com.amazonaws.ec2",
  128    128   
        "ImportInstanceLaunchSpecification",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::List,
  131         -
    "group_ids",
         131  +
    "GroupIds",
  132    132   
    2,
  133    133   
)
  134    134   
.with_xml_name("GroupId");
  135    135   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_ADDITIONAL_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$AdditionalInfo",
  138    138   
        "com.amazonaws.ec2",
  139    139   
        "ImportInstanceLaunchSpecification",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "additional_info",
         142  +
    "AdditionalInfo",
  143    143   
    3,
  144    144   
)
  145    145   
.with_xml_name("additionalInfo");
  146    146   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_USER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$UserData",
  149    149   
        "com.amazonaws.ec2",
  150    150   
        "ImportInstanceLaunchSpecification",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153         -
    "user_data",
         153  +
    "UserData",
  154    154   
    4,
  155    155   
)
  156    156   
.with_xml_name("userData");
  157    157   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$InstanceType",
  160    160   
        "com.amazonaws.ec2",
  161    161   
        "ImportInstanceLaunchSpecification",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::String,
  164         -
    "instance_type",
         164  +
    "InstanceType",
  165    165   
    5,
  166    166   
)
  167    167   
.with_xml_name("instanceType");
  168    168   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$Placement",
  171    171   
        "com.amazonaws.ec2",
  172    172   
        "ImportInstanceLaunchSpecification",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::Structure,
  175         -
    "placement",
         175  +
    "Placement",
  176    176   
    6,
  177    177   
)
  178    178   
.with_xml_name("placement");
  179    179   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static(
  181    181   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$Monitoring",
  182    182   
        "com.amazonaws.ec2",
  183    183   
        "ImportInstanceLaunchSpecification",
  184    184   
    ),
  185    185   
    ::aws_smithy_schema::ShapeType::Boolean,
  186         -
    "monitoring",
         186  +
    "Monitoring",
  187    187   
    7,
  188    188   
)
  189    189   
.with_xml_name("monitoring");
  190    190   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  191    191   
    ::aws_smithy_schema::ShapeId::from_static(
  192    192   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$SubnetId",
  193    193   
        "com.amazonaws.ec2",
  194    194   
        "ImportInstanceLaunchSpecification",
  195    195   
    ),
  196    196   
    ::aws_smithy_schema::ShapeType::String,
  197         -
    "subnet_id",
         197  +
    "SubnetId",
  198    198   
    8,
  199    199   
)
  200    200   
.with_xml_name("subnetId");
  201    201   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_INSTANCE_INITIATED_SHUTDOWN_BEHAVIOR: ::aws_smithy_schema::Schema =
  202    202   
    ::aws_smithy_schema::Schema::new_member(
  203    203   
        ::aws_smithy_schema::ShapeId::from_static(
  204    204   
            "com.amazonaws.ec2#ImportInstanceLaunchSpecification$InstanceInitiatedShutdownBehavior",
  205    205   
            "com.amazonaws.ec2",
  206    206   
            "ImportInstanceLaunchSpecification",
  207    207   
        ),
  208    208   
        ::aws_smithy_schema::ShapeType::String,
  209         -
        "instance_initiated_shutdown_behavior",
         209  +
        "InstanceInitiatedShutdownBehavior",
  210    210   
        9,
  211    211   
    )
  212    212   
    .with_xml_name("instanceInitiatedShutdownBehavior");
  213    213   
static IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  214    214   
    ::aws_smithy_schema::ShapeId::from_static(
  215    215   
        "com.amazonaws.ec2#ImportInstanceLaunchSpecification$PrivateIpAddress",
  216    216   
        "com.amazonaws.ec2",
  217    217   
        "ImportInstanceLaunchSpecification",
  218    218   
    ),
  219    219   
    ::aws_smithy_schema::ShapeType::String,
  220         -
    "private_ip_address",
         220  +
    "PrivateIpAddress",
  221    221   
    10,
  222    222   
)
  223    223   
.with_xml_name("privateIpAddress");
  224    224   
static IMPORTINSTANCELAUNCHSPECIFICATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  225    225   
    IMPORTINSTANCELAUNCHSPECIFICATION_SCHEMA_ID,
  226    226   
    ::aws_smithy_schema::ShapeType::Structure,
  227    227   
    &[
  228    228   
        &IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_ARCHITECTURE,
  229    229   
        &IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_GROUP_NAMES,
  230    230   
        &IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_GROUP_IDS,
@@ -278,278 +411,402 @@
  298    298   
            )?;
  299    299   
        }
  300    300   
        if let Some(ref val) = self.private_ip_address {
  301    301   
            ser.write_string(&IMPORTINSTANCELAUNCHSPECIFICATION_MEMBER_PRIVATE_IP_ADDRESS, val)?;
  302    302   
        }
  303    303   
        Ok(())
  304    304   
    }
  305    305   
}
  306    306   
impl ImportInstanceLaunchSpecification {
  307    307   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  308         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  309         -
        deserializer: &mut D,
         308  +
    pub fn deserialize(
         309  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  310    310   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  311    311   
        #[allow(unused_variables, unused_mut)]
  312    312   
        let mut builder = Self::builder();
  313    313   
        #[allow(
  314    314   
            unused_variables,
  315    315   
            unreachable_code,
  316    316   
            clippy::single_match,
  317    317   
            clippy::match_single_binding,
  318    318   
            clippy::diverging_sub_expression
  319    319   
        )]
  320         -
        deserializer.read_struct(&IMPORTINSTANCELAUNCHSPECIFICATION_SCHEMA, (), |_, member, deser| {
         320  +
        deserializer.read_struct(&IMPORTINSTANCELAUNCHSPECIFICATION_SCHEMA, &mut |member, deser| {
  321    321   
            match member.member_index() {
  322    322   
                Some(0) => {
  323    323   
                    builder.architecture = Some(crate::types::ArchitectureValues::from(deser.read_string(member)?.as_str()));
  324    324   
                }
  325    325   
                Some(1) => {
  326         -
                    builder.group_names = Some({
  327         -
                        let container = if let Some(cap) = deser.container_size() {
  328         -
                            Vec::with_capacity(cap)
  329         -
                        } else {
  330         -
                            Vec::new()
  331         -
                        };
  332         -
                        deser.read_list(member, container, |mut list, deser| {
  333         -
                            list.push(deser.read_string(member)?);
  334         -
                            Ok(list)
  335         -
                        })?
  336         -
                    });
         326  +
                    builder.group_names = Some(deser.read_string_list(member)?);
  337    327   
                }
  338    328   
                Some(2) => {
  339         -
                    builder.group_ids = Some({
  340         -
                        let container = if let Some(cap) = deser.container_size() {
  341         -
                            Vec::with_capacity(cap)
  342         -
                        } else {
  343         -
                            Vec::new()
  344         -
                        };
  345         -
                        deser.read_list(member, container, |mut list, deser| {
  346         -
                            list.push(deser.read_string(member)?);
  347         -
                            Ok(list)
  348         -
                        })?
  349         -
                    });
         329  +
                    builder.group_ids = Some(deser.read_string_list(member)?);
  350    330   
                }
  351    331   
                Some(3) => {
  352    332   
                    builder.additional_info = Some(deser.read_string(member)?);
  353    333   
                }
  354    334   
                Some(4) => {
  355    335   
                    builder.user_data = Some(crate::types::UserData::deserialize(deser)?);
  356    336   
                }
  357    337   
                Some(5) => {
  358    338   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  359    339   
                }
  360    340   
                Some(6) => {
  361    341   
                    builder.placement = Some(crate::types::Placement::deserialize(deser)?);
  362    342   
                }
  363    343   
                Some(7) => {
  364    344   
                    builder.monitoring = Some(deser.read_boolean(member)?);
  365    345   
                }
  366    346   
                Some(8) => {
  367    347   
                    builder.subnet_id = Some(deser.read_string(member)?);
  368    348   
                }
  369    349   
                Some(9) => {
  370    350   
                    builder.instance_initiated_shutdown_behavior = Some(crate::types::ShutdownBehavior::from(deser.read_string(member)?.as_str()));
  371    351   
                }
  372    352   
                Some(10) => {
  373    353   
                    builder.private_ip_address = Some(deser.read_string(member)?);
  374    354   
                }
  375    355   
                _ => {}
  376    356   
            }
  377    357   
            Ok(())
  378    358   
        })?;
  379    359   
        Ok(builder.build())
  380    360   
    }
  381    361   
}
         362  +
impl ImportInstanceLaunchSpecification {
         363  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         364  +
    pub fn deserialize_with_response(
         365  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         366  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         367  +
        _status: u16,
         368  +
        _body: &[u8],
         369  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         370  +
        Self::deserialize(deserializer)
         371  +
    }
         372  +
}
  382    373   
impl ImportInstanceLaunchSpecification {
  383    374   
    /// Creates a new builder-style object to manufacture [`ImportInstanceLaunchSpecification`](crate::types::ImportInstanceLaunchSpecification).
  384    375   
    pub fn builder() -> crate::types::builders::ImportInstanceLaunchSpecificationBuilder {
  385    376   
        crate::types::builders::ImportInstanceLaunchSpecificationBuilder::default()
  386    377   
    }
  387    378   
}
  388    379   
  389    380   
/// A builder for [`ImportInstanceLaunchSpecification`](crate::types::ImportInstanceLaunchSpecification).
  390    381   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  391    382   
#[non_exhaustive]

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

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

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

@@ -40,40 +278,289 @@
   60     60   
    "com.amazonaws.ec2",
   61     61   
    "ImportInstanceVolumeDetailItem",
   62     62   
);
   63     63   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$AvailabilityZone",
   66     66   
        "com.amazonaws.ec2",
   67     67   
        "ImportInstanceVolumeDetailItem",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "availability_zone",
          70  +
    "AvailabilityZone",
   71     71   
    0,
   72     72   
)
   73     73   
.with_xml_name("availabilityZone");
   74     74   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$AvailabilityZoneId",
   77     77   
        "com.amazonaws.ec2",
   78     78   
        "ImportInstanceVolumeDetailItem",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "availability_zone_id",
          81  +
    "AvailabilityZoneId",
   82     82   
    1,
   83     83   
)
   84     84   
.with_xml_name("availabilityZoneId");
   85     85   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_BYTES_CONVERTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$BytesConverted",
   88     88   
        "com.amazonaws.ec2",
   89     89   
        "ImportInstanceVolumeDetailItem",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Long,
   92         -
    "bytes_converted",
          92  +
    "BytesConverted",
   93     93   
    2,
   94     94   
)
   95     95   
.with_xml_name("bytesConverted");
   96     96   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$Description",
   99     99   
        "com.amazonaws.ec2",
  100    100   
        "ImportInstanceVolumeDetailItem",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::String,
  103         -
    "description",
         103  +
    "Description",
  104    104   
    3,
  105    105   
)
  106    106   
.with_xml_name("description");
  107    107   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_IMAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$Image",
  110    110   
        "com.amazonaws.ec2",
  111    111   
        "ImportInstanceVolumeDetailItem",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Structure,
  114         -
    "image",
         114  +
    "Image",
  115    115   
    4,
  116    116   
)
  117    117   
.with_xml_name("image");
  118    118   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$Status",
  121    121   
        "com.amazonaws.ec2",
  122    122   
        "ImportInstanceVolumeDetailItem",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "status",
         125  +
    "Status",
  126    126   
    5,
  127    127   
)
  128    128   
.with_xml_name("status");
  129    129   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$StatusMessage",
  132    132   
        "com.amazonaws.ec2",
  133    133   
        "ImportInstanceVolumeDetailItem",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "status_message",
         136  +
    "StatusMessage",
  137    137   
    6,
  138    138   
)
  139    139   
.with_xml_name("statusMessage");
  140    140   
static IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_VOLUME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.ec2#ImportInstanceVolumeDetailItem$Volume",
  143    143   
        "com.amazonaws.ec2",
  144    144   
        "ImportInstanceVolumeDetailItem",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::Structure,
  147         -
    "volume",
         147  +
    "Volume",
  148    148   
    7,
  149    149   
)
  150    150   
.with_xml_name("volume");
  151    151   
static IMPORTINSTANCEVOLUMEDETAILITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  152    152   
    IMPORTINSTANCEVOLUMEDETAILITEM_SCHEMA_ID,
  153    153   
    ::aws_smithy_schema::ShapeType::Structure,
  154    154   
    &[
  155    155   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_AVAILABILITY_ZONE,
  156    156   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_AVAILABILITY_ZONE_ID,
  157    157   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_BYTES_CONVERTED,
  158    158   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_DESCRIPTION,
  159    159   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_IMAGE,
  160    160   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_STATUS,
  161    161   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_STATUS_MESSAGE,
  162    162   
        &IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_VOLUME,
  163    163   
    ],
  164    164   
);
  165    165   
impl ImportInstanceVolumeDetailItem {
  166    166   
    /// The schema for this shape.
  167    167   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTINSTANCEVOLUMEDETAILITEM_SCHEMA;
  168    168   
}
  169    169   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportInstanceVolumeDetailItem {
  170    170   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  171    171   
    fn serialize_members(
  172    172   
        &self,
  173    173   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  174    174   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  175    175   
        if let Some(ref val) = self.availability_zone {
  176    176   
            ser.write_string(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_AVAILABILITY_ZONE, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.availability_zone_id {
  179    179   
            ser.write_string(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_AVAILABILITY_ZONE_ID, val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.bytes_converted {
  182    182   
            ser.write_long(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_BYTES_CONVERTED, *val)?;
  183    183   
        }
  184    184   
        if let Some(ref val) = self.description {
  185    185   
            ser.write_string(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_DESCRIPTION, val)?;
  186    186   
        }
  187    187   
        if let Some(ref val) = self.image {
  188    188   
            ser.write_struct(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_IMAGE, val)?;
  189    189   
        }
  190    190   
        if let Some(ref val) = self.status {
  191    191   
            ser.write_string(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_STATUS, val)?;
  192    192   
        }
  193    193   
        if let Some(ref val) = self.status_message {
  194    194   
            ser.write_string(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_STATUS_MESSAGE, val)?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.volume {
  197    197   
            ser.write_struct(&IMPORTINSTANCEVOLUMEDETAILITEM_MEMBER_VOLUME, val)?;
  198    198   
        }
  199    199   
        Ok(())
  200    200   
    }
  201    201   
}
  202    202   
impl ImportInstanceVolumeDetailItem {
  203    203   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  204         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  205         -
        deserializer: &mut D,
         204  +
    pub fn deserialize(
         205  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  206    206   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  207    207   
        #[allow(unused_variables, unused_mut)]
  208    208   
        let mut builder = Self::builder();
  209    209   
        #[allow(
  210    210   
            unused_variables,
  211    211   
            unreachable_code,
  212    212   
            clippy::single_match,
  213    213   
            clippy::match_single_binding,
  214    214   
            clippy::diverging_sub_expression
  215    215   
        )]
  216         -
        deserializer.read_struct(&IMPORTINSTANCEVOLUMEDETAILITEM_SCHEMA, (), |_, member, deser| {
         216  +
        deserializer.read_struct(&IMPORTINSTANCEVOLUMEDETAILITEM_SCHEMA, &mut |member, deser| {
  217    217   
            match member.member_index() {
  218    218   
                Some(0) => {
  219    219   
                    builder.availability_zone = Some(deser.read_string(member)?);
  220    220   
                }
  221    221   
                Some(1) => {
  222    222   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  223    223   
                }
  224    224   
                Some(2) => {
  225    225   
                    builder.bytes_converted = Some(deser.read_long(member)?);
  226    226   
                }
  227    227   
                Some(3) => {
  228    228   
                    builder.description = Some(deser.read_string(member)?);
  229    229   
                }
  230    230   
                Some(4) => {
  231    231   
                    builder.image = Some(crate::types::DiskImageDescription::deserialize(deser)?);
  232    232   
                }
  233    233   
                Some(5) => {
  234    234   
                    builder.status = Some(deser.read_string(member)?);
  235    235   
                }
  236    236   
                Some(6) => {
  237    237   
                    builder.status_message = Some(deser.read_string(member)?);
  238    238   
                }
  239    239   
                Some(7) => {
  240    240   
                    builder.volume = Some(crate::types::DiskImageVolumeDescription::deserialize(deser)?);
  241    241   
                }
  242    242   
                _ => {}
  243    243   
            }
  244    244   
            Ok(())
  245    245   
        })?;
  246    246   
        Ok(builder.build())
  247    247   
    }
  248    248   
}
         249  +
impl ImportInstanceVolumeDetailItem {
         250  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         251  +
    pub fn deserialize_with_response(
         252  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         253  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         254  +
        _status: u16,
         255  +
        _body: &[u8],
         256  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         257  +
        Self::deserialize(deserializer)
         258  +
    }
         259  +
}
  249    260   
impl ImportInstanceVolumeDetailItem {
  250    261   
    /// Creates a new builder-style object to manufacture [`ImportInstanceVolumeDetailItem`](crate::types::ImportInstanceVolumeDetailItem).
  251    262   
    pub fn builder() -> crate::types::builders::ImportInstanceVolumeDetailItemBuilder {
  252    263   
        crate::types::builders::ImportInstanceVolumeDetailItemBuilder::default()
  253    264   
    }
  254    265   
}
  255    266   
  256    267   
/// A builder for [`ImportInstanceVolumeDetailItem`](crate::types::ImportInstanceVolumeDetailItem).
  257    268   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  258    269   
#[non_exhaustive]

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

@@ -15,15 +195,203 @@
   35     35   
}
   36     36   
static IMPORTSNAPSHOTTASK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportSnapshotTask", "com.amazonaws.ec2", "ImportSnapshotTask");
   38     38   
static IMPORTSNAPSHOTTASK_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ec2#ImportSnapshotTask$Description",
   41     41   
        "com.amazonaws.ec2",
   42     42   
        "ImportSnapshotTask",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "description",
          45  +
    "Description",
   46     46   
    0,
   47     47   
)
   48     48   
.with_xml_name("description");
   49     49   
static IMPORTSNAPSHOTTASK_MEMBER_IMPORT_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.ec2#ImportSnapshotTask$ImportTaskId",
   52     52   
        "com.amazonaws.ec2",
   53     53   
        "ImportSnapshotTask",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "import_task_id",
          56  +
    "ImportTaskId",
   57     57   
    1,
   58     58   
)
   59     59   
.with_xml_name("importTaskId");
   60     60   
static IMPORTSNAPSHOTTASK_MEMBER_SNAPSHOT_TASK_DETAIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.ec2#ImportSnapshotTask$SnapshotTaskDetail",
   63     63   
        "com.amazonaws.ec2",
   64     64   
        "ImportSnapshotTask",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67         -
    "snapshot_task_detail",
          67  +
    "SnapshotTaskDetail",
   68     68   
    2,
   69     69   
)
   70     70   
.with_xml_name("snapshotTaskDetail");
   71     71   
static IMPORTSNAPSHOTTASK_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ImportSnapshotTask$Tags", "com.amazonaws.ec2", "ImportSnapshotTask"),
   73     73   
    ::aws_smithy_schema::ShapeType::List,
   74         -
    "tags",
          74  +
    "Tags",
   75     75   
    3,
   76     76   
)
   77     77   
.with_xml_name("tagSet");
   78     78   
static IMPORTSNAPSHOTTASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   79     79   
    IMPORTSNAPSHOTTASK_SCHEMA_ID,
   80     80   
    ::aws_smithy_schema::ShapeType::Structure,
   81     81   
    &[
   82     82   
        &IMPORTSNAPSHOTTASK_MEMBER_DESCRIPTION,
   83     83   
        &IMPORTSNAPSHOTTASK_MEMBER_IMPORT_TASK_ID,
   84     84   
        &IMPORTSNAPSHOTTASK_MEMBER_SNAPSHOT_TASK_DETAIL,
   85     85   
        &IMPORTSNAPSHOTTASK_MEMBER_TAGS,
   86     86   
    ],
   87     87   
);
   88     88   
impl ImportSnapshotTask {
   89     89   
    /// The schema for this shape.
   90     90   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTSNAPSHOTTASK_SCHEMA;
   91     91   
}
   92     92   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportSnapshotTask {
   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.description {
   99     99   
            ser.write_string(&IMPORTSNAPSHOTTASK_MEMBER_DESCRIPTION, val)?;
  100    100   
        }
  101    101   
        if let Some(ref val) = self.import_task_id {
  102    102   
            ser.write_string(&IMPORTSNAPSHOTTASK_MEMBER_IMPORT_TASK_ID, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.snapshot_task_detail {
  105    105   
            ser.write_struct(&IMPORTSNAPSHOTTASK_MEMBER_SNAPSHOT_TASK_DETAIL, val)?;
  106    106   
        }
  107    107   
        if let Some(ref val) = self.tags {
  108    108   
            ser.write_list(
  109    109   
                &IMPORTSNAPSHOTTASK_MEMBER_TAGS,
  110    110   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  111    111   
                    for item in val {
  112    112   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  113    113   
                    }
  114    114   
                    Ok(())
  115    115   
                },
  116    116   
            )?;
  117    117   
        }
  118    118   
        Ok(())
  119    119   
    }
  120    120   
}
  121    121   
impl ImportSnapshotTask {
  122    122   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  123         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  124         -
        deserializer: &mut D,
         123  +
    pub fn deserialize(
         124  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  125    125   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  126    126   
        #[allow(unused_variables, unused_mut)]
  127    127   
        let mut builder = Self::builder();
  128    128   
        #[allow(
  129    129   
            unused_variables,
  130    130   
            unreachable_code,
  131    131   
            clippy::single_match,
  132    132   
            clippy::match_single_binding,
  133    133   
            clippy::diverging_sub_expression
  134    134   
        )]
  135         -
        deserializer.read_struct(&IMPORTSNAPSHOTTASK_SCHEMA, (), |_, member, deser| {
         135  +
        deserializer.read_struct(&IMPORTSNAPSHOTTASK_SCHEMA, &mut |member, deser| {
  136    136   
            match member.member_index() {
  137    137   
                Some(0) => {
  138    138   
                    builder.description = Some(deser.read_string(member)?);
  139    139   
                }
  140    140   
                Some(1) => {
  141    141   
                    builder.import_task_id = Some(deser.read_string(member)?);
  142    142   
                }
  143    143   
                Some(2) => {
  144    144   
                    builder.snapshot_task_detail = Some(crate::types::SnapshotTaskDetail::deserialize(deser)?);
  145    145   
                }
  146    146   
                Some(3) => {
  147    147   
                    builder.tags = Some({
  148         -
                        let container = if let Some(cap) = deser.container_size() {
  149         -
                            Vec::with_capacity(cap)
  150         -
                        } else {
  151         -
                            Vec::new()
  152         -
                        };
  153         -
                        deser.read_list(member, container, |mut list, deser| {
  154         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  155         -
                            Ok(list)
  156         -
                        })?
         148  +
                        let mut container = Vec::new();
         149  +
                        deser.read_list(member, &mut |deser| {
         150  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         151  +
                            Ok(())
         152  +
                        })?;
         153  +
                        container
  157    154   
                    });
  158    155   
                }
  159    156   
                _ => {}
  160    157   
            }
  161    158   
            Ok(())
  162    159   
        })?;
  163    160   
        Ok(builder.build())
  164    161   
    }
  165    162   
}
         163  +
impl ImportSnapshotTask {
         164  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         165  +
    pub fn deserialize_with_response(
         166  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         167  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         168  +
        _status: u16,
         169  +
        _body: &[u8],
         170  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         171  +
        Self::deserialize(deserializer)
         172  +
    }
         173  +
}
  166    174   
impl ImportSnapshotTask {
  167    175   
    /// Creates a new builder-style object to manufacture [`ImportSnapshotTask`](crate::types::ImportSnapshotTask).
  168    176   
    pub fn builder() -> crate::types::builders::ImportSnapshotTaskBuilder {
  169    177   
        crate::types::builders::ImportSnapshotTaskBuilder::default()
  170    178   
    }
  171    179   
}
  172    180   
  173    181   
/// A builder for [`ImportSnapshotTask`](crate::types::ImportSnapshotTask).
  174    182   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  175    183   
#[non_exhaustive]

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

@@ -28,28 +230,241 @@
   48     48   
    "com.amazonaws.ec2",
   49     49   
    "ImportVolumeTaskDetails",
   50     50   
);
   51     51   
static IMPORTVOLUMETASKDETAILS_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2#ImportVolumeTaskDetails$AvailabilityZone",
   54     54   
        "com.amazonaws.ec2",
   55     55   
        "ImportVolumeTaskDetails",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "availability_zone",
          58  +
    "AvailabilityZone",
   59     59   
    0,
   60     60   
)
   61     61   
.with_xml_name("availabilityZone");
   62     62   
static IMPORTVOLUMETASKDETAILS_MEMBER_AVAILABILITY_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.ec2#ImportVolumeTaskDetails$AvailabilityZoneId",
   65     65   
        "com.amazonaws.ec2",
   66     66   
        "ImportVolumeTaskDetails",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "availability_zone_id",
          69  +
    "AvailabilityZoneId",
   70     70   
    1,
   71     71   
)
   72     72   
.with_xml_name("availabilityZoneId");
   73     73   
static IMPORTVOLUMETASKDETAILS_MEMBER_BYTES_CONVERTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2#ImportVolumeTaskDetails$BytesConverted",
   76     76   
        "com.amazonaws.ec2",
   77     77   
        "ImportVolumeTaskDetails",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Long,
   80         -
    "bytes_converted",
          80  +
    "BytesConverted",
   81     81   
    2,
   82     82   
)
   83     83   
.with_xml_name("bytesConverted");
   84     84   
static IMPORTVOLUMETASKDETAILS_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.ec2#ImportVolumeTaskDetails$Description",
   87     87   
        "com.amazonaws.ec2",
   88     88   
        "ImportVolumeTaskDetails",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "description",
          91  +
    "Description",
   92     92   
    3,
   93     93   
)
   94     94   
.with_xml_name("description");
   95     95   
static IMPORTVOLUMETASKDETAILS_MEMBER_IMAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.ec2#ImportVolumeTaskDetails$Image",
   98     98   
        "com.amazonaws.ec2",
   99     99   
        "ImportVolumeTaskDetails",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102         -
    "image",
         102  +
    "Image",
  103    103   
    4,
  104    104   
)
  105    105   
.with_xml_name("image");
  106    106   
static IMPORTVOLUMETASKDETAILS_MEMBER_VOLUME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ec2#ImportVolumeTaskDetails$Volume",
  109    109   
        "com.amazonaws.ec2",
  110    110   
        "ImportVolumeTaskDetails",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113         -
    "volume",
         113  +
    "Volume",
  114    114   
    5,
  115    115   
)
  116    116   
.with_xml_name("volume");
  117    117   
static IMPORTVOLUMETASKDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  118    118   
    IMPORTVOLUMETASKDETAILS_SCHEMA_ID,
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120    120   
    &[
  121    121   
        &IMPORTVOLUMETASKDETAILS_MEMBER_AVAILABILITY_ZONE,
  122    122   
        &IMPORTVOLUMETASKDETAILS_MEMBER_AVAILABILITY_ZONE_ID,
  123    123   
        &IMPORTVOLUMETASKDETAILS_MEMBER_BYTES_CONVERTED,
  124    124   
        &IMPORTVOLUMETASKDETAILS_MEMBER_DESCRIPTION,
  125    125   
        &IMPORTVOLUMETASKDETAILS_MEMBER_IMAGE,
  126    126   
        &IMPORTVOLUMETASKDETAILS_MEMBER_VOLUME,
  127    127   
    ],
  128    128   
);
  129    129   
impl ImportVolumeTaskDetails {
  130    130   
    /// The schema for this shape.
  131    131   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &IMPORTVOLUMETASKDETAILS_SCHEMA;
  132    132   
}
  133    133   
impl ::aws_smithy_schema::serde::SerializableStruct for ImportVolumeTaskDetails {
  134    134   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  135    135   
    fn serialize_members(
  136    136   
        &self,
  137    137   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  138    138   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        if let Some(ref val) = self.availability_zone {
  140    140   
            ser.write_string(&IMPORTVOLUMETASKDETAILS_MEMBER_AVAILABILITY_ZONE, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.availability_zone_id {
  143    143   
            ser.write_string(&IMPORTVOLUMETASKDETAILS_MEMBER_AVAILABILITY_ZONE_ID, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.bytes_converted {
  146    146   
            ser.write_long(&IMPORTVOLUMETASKDETAILS_MEMBER_BYTES_CONVERTED, *val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.description {
  149    149   
            ser.write_string(&IMPORTVOLUMETASKDETAILS_MEMBER_DESCRIPTION, val)?;
  150    150   
        }
  151    151   
        if let Some(ref val) = self.image {
  152    152   
            ser.write_struct(&IMPORTVOLUMETASKDETAILS_MEMBER_IMAGE, val)?;
  153    153   
        }
  154    154   
        if let Some(ref val) = self.volume {
  155    155   
            ser.write_struct(&IMPORTVOLUMETASKDETAILS_MEMBER_VOLUME, val)?;
  156    156   
        }
  157    157   
        Ok(())
  158    158   
    }
  159    159   
}
  160    160   
impl ImportVolumeTaskDetails {
  161    161   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  162         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  163         -
        deserializer: &mut D,
         162  +
    pub fn deserialize(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  164    164   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  165    165   
        #[allow(unused_variables, unused_mut)]
  166    166   
        let mut builder = Self::builder();
  167    167   
        #[allow(
  168    168   
            unused_variables,
  169    169   
            unreachable_code,
  170    170   
            clippy::single_match,
  171    171   
            clippy::match_single_binding,
  172    172   
            clippy::diverging_sub_expression
  173    173   
        )]
  174         -
        deserializer.read_struct(&IMPORTVOLUMETASKDETAILS_SCHEMA, (), |_, member, deser| {
         174  +
        deserializer.read_struct(&IMPORTVOLUMETASKDETAILS_SCHEMA, &mut |member, deser| {
  175    175   
            match member.member_index() {
  176    176   
                Some(0) => {
  177    177   
                    builder.availability_zone = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(1) => {
  180    180   
                    builder.availability_zone_id = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(2) => {
  183    183   
                    builder.bytes_converted = Some(deser.read_long(member)?);
  184    184   
                }
  185    185   
                Some(3) => {
  186    186   
                    builder.description = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                Some(4) => {
  189    189   
                    builder.image = Some(crate::types::DiskImageDescription::deserialize(deser)?);
  190    190   
                }
  191    191   
                Some(5) => {
  192    192   
                    builder.volume = Some(crate::types::DiskImageVolumeDescription::deserialize(deser)?);
  193    193   
                }
  194    194   
                _ => {}
  195    195   
            }
  196    196   
            Ok(())
  197    197   
        })?;
  198    198   
        Ok(builder.build())
  199    199   
    }
  200    200   
}
         201  +
impl ImportVolumeTaskDetails {
         202  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        _body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        Self::deserialize(deserializer)
         210  +
    }
         211  +
}
  201    212   
impl ImportVolumeTaskDetails {
  202    213   
    /// Creates a new builder-style object to manufacture [`ImportVolumeTaskDetails`](crate::types::ImportVolumeTaskDetails).
  203    214   
    pub fn builder() -> crate::types::builders::ImportVolumeTaskDetailsBuilder {
  204    215   
        crate::types::builders::ImportVolumeTaskDetailsBuilder::default()
  205    216   
    }
  206    217   
}
  207    218   
  208    219   
/// A builder for [`ImportVolumeTaskDetails`](crate::types::ImportVolumeTaskDetails).
  209    220   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  210    221   
#[non_exhaustive]

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

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

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

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

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

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

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

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

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

@@ -383,383 +864,864 @@
  403    403   
    /// <p>A Carrier IP address only applies to an instance launched in a subnet associated with a Wavelength Zone.</p>
  404    404   
    pub fn public_ip_address(&self) -> ::std::option::Option<&str> {
  405    405   
        self.public_ip_address.as_deref()
  406    406   
    }
  407    407   
}
  408    408   
static INSTANCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  409    409   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance", "com.amazonaws.ec2", "Instance");
  410    410   
static INSTANCE_MEMBER_ARCHITECTURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  411    411   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Architecture", "com.amazonaws.ec2", "Instance"),
  412    412   
    ::aws_smithy_schema::ShapeType::String,
  413         -
    "architecture",
         413  +
    "Architecture",
  414    414   
    0,
  415    415   
)
  416    416   
.with_xml_name("architecture");
  417    417   
static INSTANCE_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  418    418   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$BlockDeviceMappings", "com.amazonaws.ec2", "Instance"),
  419    419   
    ::aws_smithy_schema::ShapeType::List,
  420         -
    "block_device_mappings",
         420  +
    "BlockDeviceMappings",
  421    421   
    1,
  422    422   
)
  423    423   
.with_xml_name("blockDeviceMapping");
  424    424   
static INSTANCE_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  425    425   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$ClientToken", "com.amazonaws.ec2", "Instance"),
  426    426   
    ::aws_smithy_schema::ShapeType::String,
  427         -
    "client_token",
         427  +
    "ClientToken",
  428    428   
    2,
  429    429   
)
  430    430   
.with_xml_name("clientToken");
  431    431   
static INSTANCE_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  432    432   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$EbsOptimized", "com.amazonaws.ec2", "Instance"),
  433    433   
    ::aws_smithy_schema::ShapeType::Boolean,
  434         -
    "ebs_optimized",
         434  +
    "EbsOptimized",
  435    435   
    3,
  436    436   
)
  437    437   
.with_xml_name("ebsOptimized");
  438    438   
static INSTANCE_MEMBER_ENA_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  439    439   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$EnaSupport", "com.amazonaws.ec2", "Instance"),
  440    440   
    ::aws_smithy_schema::ShapeType::Boolean,
  441         -
    "ena_support",
         441  +
    "EnaSupport",
  442    442   
    4,
  443    443   
)
  444    444   
.with_xml_name("enaSupport");
  445    445   
static INSTANCE_MEMBER_HYPERVISOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  446    446   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Hypervisor", "com.amazonaws.ec2", "Instance"),
  447    447   
    ::aws_smithy_schema::ShapeType::String,
  448         -
    "hypervisor",
         448  +
    "Hypervisor",
  449    449   
    5,
  450    450   
)
  451    451   
.with_xml_name("hypervisor");
  452    452   
static INSTANCE_MEMBER_IAM_INSTANCE_PROFILE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  453    453   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$IamInstanceProfile", "com.amazonaws.ec2", "Instance"),
  454    454   
    ::aws_smithy_schema::ShapeType::Structure,
  455         -
    "iam_instance_profile",
         455  +
    "IamInstanceProfile",
  456    456   
    6,
  457    457   
)
  458    458   
.with_xml_name("iamInstanceProfile");
  459    459   
static INSTANCE_MEMBER_INSTANCE_LIFECYCLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  460    460   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$InstanceLifecycle", "com.amazonaws.ec2", "Instance"),
  461    461   
    ::aws_smithy_schema::ShapeType::String,
  462         -
    "instance_lifecycle",
         462  +
    "InstanceLifecycle",
  463    463   
    7,
  464    464   
)
  465    465   
.with_xml_name("instanceLifecycle");
  466    466   
static INSTANCE_MEMBER_ELASTIC_GPU_ASSOCIATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  467    467   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$ElasticGpuAssociations", "com.amazonaws.ec2", "Instance"),
  468    468   
    ::aws_smithy_schema::ShapeType::List,
  469         -
    "elastic_gpu_associations",
         469  +
    "ElasticGpuAssociations",
  470    470   
    8,
  471    471   
)
  472    472   
.with_xml_name("elasticGpuAssociationSet");
  473    473   
static INSTANCE_MEMBER_ELASTIC_INFERENCE_ACCELERATOR_ASSOCIATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  474    474   
    ::aws_smithy_schema::ShapeId::from_static(
  475    475   
        "com.amazonaws.ec2#Instance$ElasticInferenceAcceleratorAssociations",
  476    476   
        "com.amazonaws.ec2",
  477    477   
        "Instance",
  478    478   
    ),
  479    479   
    ::aws_smithy_schema::ShapeType::List,
  480         -
    "elastic_inference_accelerator_associations",
         480  +
    "ElasticInferenceAcceleratorAssociations",
  481    481   
    9,
  482    482   
)
  483    483   
.with_xml_name("elasticInferenceAcceleratorAssociationSet");
  484    484   
static INSTANCE_MEMBER_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  485    485   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$NetworkInterfaces", "com.amazonaws.ec2", "Instance"),
  486    486   
    ::aws_smithy_schema::ShapeType::List,
  487         -
    "network_interfaces",
         487  +
    "NetworkInterfaces",
  488    488   
    10,
  489    489   
)
  490    490   
.with_xml_name("networkInterfaceSet");
  491    491   
static INSTANCE_MEMBER_OUTPOST_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  492    492   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$OutpostArn", "com.amazonaws.ec2", "Instance"),
  493    493   
    ::aws_smithy_schema::ShapeType::String,
  494         -
    "outpost_arn",
         494  +
    "OutpostArn",
  495    495   
    11,
  496    496   
)
  497    497   
.with_xml_name("outpostArn");
  498    498   
static INSTANCE_MEMBER_ROOT_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  499    499   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$RootDeviceName", "com.amazonaws.ec2", "Instance"),
  500    500   
    ::aws_smithy_schema::ShapeType::String,
  501         -
    "root_device_name",
         501  +
    "RootDeviceName",
  502    502   
    12,
  503    503   
)
  504    504   
.with_xml_name("rootDeviceName");
  505    505   
static INSTANCE_MEMBER_ROOT_DEVICE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  506    506   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$RootDeviceType", "com.amazonaws.ec2", "Instance"),
  507    507   
    ::aws_smithy_schema::ShapeType::String,
  508         -
    "root_device_type",
         508  +
    "RootDeviceType",
  509    509   
    13,
  510    510   
)
  511    511   
.with_xml_name("rootDeviceType");
  512    512   
static INSTANCE_MEMBER_SECURITY_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  513    513   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$SecurityGroups", "com.amazonaws.ec2", "Instance"),
  514    514   
    ::aws_smithy_schema::ShapeType::List,
  515         -
    "security_groups",
         515  +
    "SecurityGroups",
  516    516   
    14,
  517    517   
)
  518    518   
.with_xml_name("groupSet");
  519    519   
static INSTANCE_MEMBER_SOURCE_DEST_CHECK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  520    520   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$SourceDestCheck", "com.amazonaws.ec2", "Instance"),
  521    521   
    ::aws_smithy_schema::ShapeType::Boolean,
  522         -
    "source_dest_check",
         522  +
    "SourceDestCheck",
  523    523   
    15,
  524    524   
)
  525    525   
.with_xml_name("sourceDestCheck");
  526    526   
static INSTANCE_MEMBER_SPOT_INSTANCE_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  527    527   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$SpotInstanceRequestId", "com.amazonaws.ec2", "Instance"),
  528    528   
    ::aws_smithy_schema::ShapeType::String,
  529         -
    "spot_instance_request_id",
         529  +
    "SpotInstanceRequestId",
  530    530   
    16,
  531    531   
)
  532    532   
.with_xml_name("spotInstanceRequestId");
  533    533   
static INSTANCE_MEMBER_SRIOV_NET_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  534    534   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$SriovNetSupport", "com.amazonaws.ec2", "Instance"),
  535    535   
    ::aws_smithy_schema::ShapeType::String,
  536         -
    "sriov_net_support",
         536  +
    "SriovNetSupport",
  537    537   
    17,
  538    538   
)
  539    539   
.with_xml_name("sriovNetSupport");
  540    540   
static INSTANCE_MEMBER_STATE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  541    541   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$StateReason", "com.amazonaws.ec2", "Instance"),
  542    542   
    ::aws_smithy_schema::ShapeType::Structure,
  543         -
    "state_reason",
         543  +
    "StateReason",
  544    544   
    18,
  545    545   
)
  546    546   
.with_xml_name("stateReason");
  547    547   
static INSTANCE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  548    548   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Tags", "com.amazonaws.ec2", "Instance"),
  549    549   
    ::aws_smithy_schema::ShapeType::List,
  550         -
    "tags",
         550  +
    "Tags",
  551    551   
    19,
  552    552   
)
  553    553   
.with_xml_name("tagSet");
  554    554   
static INSTANCE_MEMBER_VIRTUALIZATION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  555    555   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$VirtualizationType", "com.amazonaws.ec2", "Instance"),
  556    556   
    ::aws_smithy_schema::ShapeType::String,
  557         -
    "virtualization_type",
         557  +
    "VirtualizationType",
  558    558   
    20,
  559    559   
)
  560    560   
.with_xml_name("virtualizationType");
  561    561   
static INSTANCE_MEMBER_CPU_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  562    562   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$CpuOptions", "com.amazonaws.ec2", "Instance"),
  563    563   
    ::aws_smithy_schema::ShapeType::Structure,
  564         -
    "cpu_options",
         564  +
    "CpuOptions",
  565    565   
    21,
  566    566   
)
  567    567   
.with_xml_name("cpuOptions");
  568    568   
static INSTANCE_MEMBER_CAPACITY_BLOCK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  569    569   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$CapacityBlockId", "com.amazonaws.ec2", "Instance"),
  570    570   
    ::aws_smithy_schema::ShapeType::String,
  571         -
    "capacity_block_id",
         571  +
    "CapacityBlockId",
  572    572   
    22,
  573    573   
)
  574    574   
.with_xml_name("capacityBlockId");
  575    575   
static INSTANCE_MEMBER_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  576    576   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$CapacityReservationId", "com.amazonaws.ec2", "Instance"),
  577    577   
    ::aws_smithy_schema::ShapeType::String,
  578         -
    "capacity_reservation_id",
         578  +
    "CapacityReservationId",
  579    579   
    23,
  580    580   
)
  581    581   
.with_xml_name("capacityReservationId");
  582    582   
static INSTANCE_MEMBER_CAPACITY_RESERVATION_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  583    583   
    ::aws_smithy_schema::ShapeId::from_static(
  584    584   
        "com.amazonaws.ec2#Instance$CapacityReservationSpecification",
  585    585   
        "com.amazonaws.ec2",
  586    586   
        "Instance",
  587    587   
    ),
  588    588   
    ::aws_smithy_schema::ShapeType::Structure,
  589         -
    "capacity_reservation_specification",
         589  +
    "CapacityReservationSpecification",
  590    590   
    24,
  591    591   
)
  592    592   
.with_xml_name("capacityReservationSpecification");
  593    593   
static INSTANCE_MEMBER_HIBERNATION_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  594    594   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$HibernationOptions", "com.amazonaws.ec2", "Instance"),
  595    595   
    ::aws_smithy_schema::ShapeType::Structure,
  596         -
    "hibernation_options",
         596  +
    "HibernationOptions",
  597    597   
    25,
  598    598   
)
  599    599   
.with_xml_name("hibernationOptions");
  600    600   
static INSTANCE_MEMBER_LICENSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  601    601   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Licenses", "com.amazonaws.ec2", "Instance"),
  602    602   
    ::aws_smithy_schema::ShapeType::List,
  603         -
    "licenses",
         603  +
    "Licenses",
  604    604   
    26,
  605    605   
)
  606    606   
.with_xml_name("licenseSet");
  607    607   
static INSTANCE_MEMBER_METADATA_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  608    608   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$MetadataOptions", "com.amazonaws.ec2", "Instance"),
  609    609   
    ::aws_smithy_schema::ShapeType::Structure,
  610         -
    "metadata_options",
         610  +
    "MetadataOptions",
  611    611   
    27,
  612    612   
)
  613    613   
.with_xml_name("metadataOptions");
  614    614   
static INSTANCE_MEMBER_ENCLAVE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  615    615   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$EnclaveOptions", "com.amazonaws.ec2", "Instance"),
  616    616   
    ::aws_smithy_schema::ShapeType::Structure,
  617         -
    "enclave_options",
         617  +
    "EnclaveOptions",
  618    618   
    28,
  619    619   
)
  620    620   
.with_xml_name("enclaveOptions");
  621    621   
static INSTANCE_MEMBER_BOOT_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  622    622   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$BootMode", "com.amazonaws.ec2", "Instance"),
  623    623   
    ::aws_smithy_schema::ShapeType::String,
  624         -
    "boot_mode",
         624  +
    "BootMode",
  625    625   
    29,
  626    626   
)
  627    627   
.with_xml_name("bootMode");
  628    628   
static INSTANCE_MEMBER_PLATFORM_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  629    629   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$PlatformDetails", "com.amazonaws.ec2", "Instance"),
  630    630   
    ::aws_smithy_schema::ShapeType::String,
  631         -
    "platform_details",
         631  +
    "PlatformDetails",
  632    632   
    30,
  633    633   
)
  634    634   
.with_xml_name("platformDetails");
  635    635   
static INSTANCE_MEMBER_USAGE_OPERATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  636    636   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$UsageOperation", "com.amazonaws.ec2", "Instance"),
  637    637   
    ::aws_smithy_schema::ShapeType::String,
  638         -
    "usage_operation",
         638  +
    "UsageOperation",
  639    639   
    31,
  640    640   
)
  641    641   
.with_xml_name("usageOperation");
  642    642   
static INSTANCE_MEMBER_USAGE_OPERATION_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  643    643   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$UsageOperationUpdateTime", "com.amazonaws.ec2", "Instance"),
  644    644   
    ::aws_smithy_schema::ShapeType::Timestamp,
  645         -
    "usage_operation_update_time",
         645  +
    "UsageOperationUpdateTime",
  646    646   
    32,
  647    647   
)
  648    648   
.with_xml_name("usageOperationUpdateTime");
  649    649   
static INSTANCE_MEMBER_PRIVATE_DNS_NAME_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  650    650   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$PrivateDnsNameOptions", "com.amazonaws.ec2", "Instance"),
  651    651   
    ::aws_smithy_schema::ShapeType::Structure,
  652         -
    "private_dns_name_options",
         652  +
    "PrivateDnsNameOptions",
  653    653   
    33,
  654    654   
)
  655    655   
.with_xml_name("privateDnsNameOptions");
  656    656   
static INSTANCE_MEMBER_IPV6_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  657    657   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Ipv6Address", "com.amazonaws.ec2", "Instance"),
  658    658   
    ::aws_smithy_schema::ShapeType::String,
  659         -
    "ipv6_address",
         659  +
    "Ipv6Address",
  660    660   
    34,
  661    661   
)
  662    662   
.with_xml_name("ipv6Address");
  663    663   
static INSTANCE_MEMBER_TPM_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  664    664   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$TpmSupport", "com.amazonaws.ec2", "Instance"),
  665    665   
    ::aws_smithy_schema::ShapeType::String,
  666         -
    "tpm_support",
         666  +
    "TpmSupport",
  667    667   
    35,
  668    668   
)
  669    669   
.with_xml_name("tpmSupport");
  670    670   
static INSTANCE_MEMBER_MAINTENANCE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  671    671   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$MaintenanceOptions", "com.amazonaws.ec2", "Instance"),
  672    672   
    ::aws_smithy_schema::ShapeType::Structure,
  673         -
    "maintenance_options",
         673  +
    "MaintenanceOptions",
  674    674   
    36,
  675    675   
)
  676    676   
.with_xml_name("maintenanceOptions");
  677    677   
static INSTANCE_MEMBER_CURRENT_INSTANCE_BOOT_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  678    678   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$CurrentInstanceBootMode", "com.amazonaws.ec2", "Instance"),
  679    679   
    ::aws_smithy_schema::ShapeType::String,
  680         -
    "current_instance_boot_mode",
         680  +
    "CurrentInstanceBootMode",
  681    681   
    37,
  682    682   
)
  683    683   
.with_xml_name("currentInstanceBootMode");
  684    684   
static INSTANCE_MEMBER_NETWORK_PERFORMANCE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  685    685   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$NetworkPerformanceOptions", "com.amazonaws.ec2", "Instance"),
  686    686   
    ::aws_smithy_schema::ShapeType::Structure,
  687         -
    "network_performance_options",
         687  +
    "NetworkPerformanceOptions",
  688    688   
    38,
  689    689   
)
  690    690   
.with_xml_name("networkPerformanceOptions");
  691    691   
static INSTANCE_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  692    692   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Operator", "com.amazonaws.ec2", "Instance"),
  693    693   
    ::aws_smithy_schema::ShapeType::Structure,
  694         -
    "operator",
         694  +
    "Operator",
  695    695   
    39,
  696    696   
)
  697    697   
.with_xml_name("operator");
  698    698   
static INSTANCE_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  699    699   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$InstanceId", "com.amazonaws.ec2", "Instance"),
  700    700   
    ::aws_smithy_schema::ShapeType::String,
  701         -
    "instance_id",
         701  +
    "InstanceId",
  702    702   
    40,
  703    703   
)
  704    704   
.with_xml_name("instanceId");
  705    705   
static INSTANCE_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  706    706   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$ImageId", "com.amazonaws.ec2", "Instance"),
  707    707   
    ::aws_smithy_schema::ShapeType::String,
  708         -
    "image_id",
         708  +
    "ImageId",
  709    709   
    41,
  710    710   
)
  711    711   
.with_xml_name("imageId");
  712    712   
static INSTANCE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  713    713   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$State", "com.amazonaws.ec2", "Instance"),
  714    714   
    ::aws_smithy_schema::ShapeType::Structure,
  715         -
    "state",
         715  +
    "State",
  716    716   
    42,
  717    717   
)
  718    718   
.with_xml_name("instanceState");
  719    719   
static INSTANCE_MEMBER_PRIVATE_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  720    720   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$PrivateDnsName", "com.amazonaws.ec2", "Instance"),
  721    721   
    ::aws_smithy_schema::ShapeType::String,
  722         -
    "private_dns_name",
         722  +
    "PrivateDnsName",
  723    723   
    43,
  724    724   
)
  725    725   
.with_xml_name("privateDnsName");
  726    726   
static INSTANCE_MEMBER_PUBLIC_DNS_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  727    727   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$PublicDnsName", "com.amazonaws.ec2", "Instance"),
  728    728   
    ::aws_smithy_schema::ShapeType::String,
  729         -
    "public_dns_name",
         729  +
    "PublicDnsName",
  730    730   
    44,
  731    731   
)
  732    732   
.with_xml_name("dnsName");
  733    733   
static INSTANCE_MEMBER_STATE_TRANSITION_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  734    734   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$StateTransitionReason", "com.amazonaws.ec2", "Instance"),
  735    735   
    ::aws_smithy_schema::ShapeType::String,
  736         -
    "state_transition_reason",
         736  +
    "StateTransitionReason",
  737    737   
    45,
  738    738   
)
  739    739   
.with_xml_name("reason");
  740    740   
static INSTANCE_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  741    741   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$KeyName", "com.amazonaws.ec2", "Instance"),
  742    742   
    ::aws_smithy_schema::ShapeType::String,
  743         -
    "key_name",
         743  +
    "KeyName",
  744    744   
    46,
  745    745   
)
  746    746   
.with_xml_name("keyName");
  747    747   
static INSTANCE_MEMBER_AMI_LAUNCH_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  748    748   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$AmiLaunchIndex", "com.amazonaws.ec2", "Instance"),
  749    749   
    ::aws_smithy_schema::ShapeType::Integer,
  750         -
    "ami_launch_index",
         750  +
    "AmiLaunchIndex",
  751    751   
    47,
  752    752   
)
  753    753   
.with_xml_name("amiLaunchIndex");
  754    754   
static INSTANCE_MEMBER_PRODUCT_CODES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  755    755   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$ProductCodes", "com.amazonaws.ec2", "Instance"),
  756    756   
    ::aws_smithy_schema::ShapeType::List,
  757         -
    "product_codes",
         757  +
    "ProductCodes",
  758    758   
    48,
  759    759   
)
  760    760   
.with_xml_name("productCodes");
  761    761   
static INSTANCE_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  762    762   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$InstanceType", "com.amazonaws.ec2", "Instance"),
  763    763   
    ::aws_smithy_schema::ShapeType::String,
  764         -
    "instance_type",
         764  +
    "InstanceType",
  765    765   
    49,
  766    766   
)
  767    767   
.with_xml_name("instanceType");
  768    768   
static INSTANCE_MEMBER_LAUNCH_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  769    769   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$LaunchTime", "com.amazonaws.ec2", "Instance"),
  770    770   
    ::aws_smithy_schema::ShapeType::Timestamp,
  771         -
    "launch_time",
         771  +
    "LaunchTime",
  772    772   
    50,
  773    773   
)
  774    774   
.with_xml_name("launchTime");
  775    775   
static INSTANCE_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  776    776   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Placement", "com.amazonaws.ec2", "Instance"),
  777    777   
    ::aws_smithy_schema::ShapeType::Structure,
  778         -
    "placement",
         778  +
    "Placement",
  779    779   
    51,
  780    780   
)
  781    781   
.with_xml_name("placement");
  782    782   
static INSTANCE_MEMBER_KERNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  783    783   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$KernelId", "com.amazonaws.ec2", "Instance"),
  784    784   
    ::aws_smithy_schema::ShapeType::String,
  785         -
    "kernel_id",
         785  +
    "KernelId",
  786    786   
    52,
  787    787   
)
  788    788   
.with_xml_name("kernelId");
  789    789   
static INSTANCE_MEMBER_RAMDISK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  790    790   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$RamdiskId", "com.amazonaws.ec2", "Instance"),
  791    791   
    ::aws_smithy_schema::ShapeType::String,
  792         -
    "ramdisk_id",
         792  +
    "RamdiskId",
  793    793   
    53,
  794    794   
)
  795    795   
.with_xml_name("ramdiskId");
  796    796   
static INSTANCE_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  797    797   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Platform", "com.amazonaws.ec2", "Instance"),
  798    798   
    ::aws_smithy_schema::ShapeType::String,
  799         -
    "platform",
         799  +
    "Platform",
  800    800   
    54,
  801    801   
)
  802    802   
.with_xml_name("platform");
  803    803   
static INSTANCE_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  804    804   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$Monitoring", "com.amazonaws.ec2", "Instance"),
  805    805   
    ::aws_smithy_schema::ShapeType::Structure,
  806         -
    "monitoring",
         806  +
    "Monitoring",
  807    807   
    55,
  808    808   
)
  809    809   
.with_xml_name("monitoring");
  810    810   
static INSTANCE_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  811    811   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$SubnetId", "com.amazonaws.ec2", "Instance"),
  812    812   
    ::aws_smithy_schema::ShapeType::String,
  813         -
    "subnet_id",
         813  +
    "SubnetId",
  814    814   
    56,
  815    815   
)
  816    816   
.with_xml_name("subnetId");
  817    817   
static INSTANCE_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  818    818   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$VpcId", "com.amazonaws.ec2", "Instance"),
  819    819   
    ::aws_smithy_schema::ShapeType::String,
  820         -
    "vpc_id",
         820  +
    "VpcId",
  821    821   
    57,
  822    822   
)
  823    823   
.with_xml_name("vpcId");
  824    824   
static INSTANCE_MEMBER_PRIVATE_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  825    825   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$PrivateIpAddress", "com.amazonaws.ec2", "Instance"),
  826    826   
    ::aws_smithy_schema::ShapeType::String,
  827         -
    "private_ip_address",
         827  +
    "PrivateIpAddress",
  828    828   
    58,
  829    829   
)
  830    830   
.with_xml_name("privateIpAddress");
  831    831   
static INSTANCE_MEMBER_PUBLIC_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  832    832   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Instance$PublicIpAddress", "com.amazonaws.ec2", "Instance"),
  833    833   
    ::aws_smithy_schema::ShapeType::String,
  834         -
    "public_ip_address",
         834  +
    "PublicIpAddress",
  835    835   
    59,
  836    836   
)
  837    837   
.with_xml_name("ipAddress");
  838    838   
static INSTANCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  839    839   
    INSTANCE_SCHEMA_ID,
  840    840   
    ::aws_smithy_schema::ShapeType::Structure,
  841    841   
    &[
  842    842   
        &INSTANCE_MEMBER_ARCHITECTURE,
  843    843   
        &INSTANCE_MEMBER_BLOCK_DEVICE_MAPPINGS,
  844    844   
        &INSTANCE_MEMBER_CLIENT_TOKEN,
@@ -1127,1127 +1349,1328 @@
 1147   1147   
            ser.write_string(&INSTANCE_MEMBER_PRIVATE_IP_ADDRESS, val)?;
 1148   1148   
        }
 1149   1149   
        if let Some(ref val) = self.public_ip_address {
 1150   1150   
            ser.write_string(&INSTANCE_MEMBER_PUBLIC_IP_ADDRESS, val)?;
 1151   1151   
        }
 1152   1152   
        Ok(())
 1153   1153   
    }
 1154   1154   
}
 1155   1155   
impl Instance {
 1156   1156   
    /// Deserializes this structure from a [`ShapeDeserializer`].
 1157         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
 1158         -
        deserializer: &mut D,
        1157  +
    pub fn deserialize(
        1158  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
 1159   1159   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
 1160   1160   
        #[allow(unused_variables, unused_mut)]
 1161   1161   
        let mut builder = Self::builder();
 1162   1162   
        #[allow(
 1163   1163   
            unused_variables,
 1164   1164   
            unreachable_code,
 1165   1165   
            clippy::single_match,
 1166   1166   
            clippy::match_single_binding,
 1167   1167   
            clippy::diverging_sub_expression
 1168   1168   
        )]
 1169         -
        deserializer.read_struct(&INSTANCE_SCHEMA, (), |_, member, deser| {
        1169  +
        deserializer.read_struct(&INSTANCE_SCHEMA, &mut |member, deser| {
 1170   1170   
            match member.member_index() {
 1171   1171   
                Some(0) => {
 1172   1172   
                    builder.architecture = Some(crate::types::ArchitectureValues::from(deser.read_string(member)?.as_str()));
 1173   1173   
                }
 1174   1174   
                Some(1) => {
 1175   1175   
                    builder.block_device_mappings = Some({
 1176         -
                        let container = if let Some(cap) = deser.container_size() {
 1177         -
                            Vec::with_capacity(cap)
 1178         -
                        } else {
 1179         -
                            Vec::new()
 1180         -
                        };
 1181         -
                        deser.read_list(member, container, |mut list, deser| {
 1182         -
                            list.push(crate::types::InstanceBlockDeviceMapping::deserialize(deser)?);
 1183         -
                            Ok(list)
 1184         -
                        })?
        1176  +
                        let mut container = Vec::new();
        1177  +
                        deser.read_list(member, &mut |deser| {
        1178  +
                            container.push(crate::types::InstanceBlockDeviceMapping::deserialize(deser)?);
        1179  +
                            Ok(())
        1180  +
                        })?;
        1181  +
                        container
 1185   1182   
                    });
 1186   1183   
                }
 1187   1184   
                Some(2) => {
 1188   1185   
                    builder.client_token = Some(deser.read_string(member)?);
 1189   1186   
                }
 1190   1187   
                Some(3) => {
 1191   1188   
                    builder.ebs_optimized = Some(deser.read_boolean(member)?);
 1192   1189   
                }
 1193   1190   
                Some(4) => {
 1194   1191   
                    builder.ena_support = Some(deser.read_boolean(member)?);
 1195   1192   
                }
 1196   1193   
                Some(5) => {
 1197   1194   
                    builder.hypervisor = Some(crate::types::HypervisorType::from(deser.read_string(member)?.as_str()));
 1198   1195   
                }
 1199   1196   
                Some(6) => {
 1200   1197   
                    builder.iam_instance_profile = Some(crate::types::IamInstanceProfile::deserialize(deser)?);
 1201   1198   
                }
 1202   1199   
                Some(7) => {
 1203   1200   
                    builder.instance_lifecycle = Some(crate::types::InstanceLifecycleType::from(deser.read_string(member)?.as_str()));
 1204   1201   
                }
 1205   1202   
                Some(8) => {
 1206   1203   
                    builder.elastic_gpu_associations = Some({
 1207         -
                        let container = if let Some(cap) = deser.container_size() {
 1208         -
                            Vec::with_capacity(cap)
 1209         -
                        } else {
 1210         -
                            Vec::new()
 1211         -
                        };
 1212         -
                        deser.read_list(member, container, |mut list, deser| {
 1213         -
                            list.push(crate::types::ElasticGpuAssociation::deserialize(deser)?);
 1214         -
                            Ok(list)
 1215         -
                        })?
        1204  +
                        let mut container = Vec::new();
        1205  +
                        deser.read_list(member, &mut |deser| {
        1206  +
                            container.push(crate::types::ElasticGpuAssociation::deserialize(deser)?);
        1207  +
                            Ok(())
        1208  +
                        })?;
        1209  +
                        container
 1216   1210   
                    });
 1217   1211   
                }
 1218   1212   
                Some(9) => {
 1219   1213   
                    builder.elastic_inference_accelerator_associations = Some({
 1220         -
                        let container = if let Some(cap) = deser.container_size() {
 1221         -
                            Vec::with_capacity(cap)
 1222         -
                        } else {
 1223         -
                            Vec::new()
 1224         -
                        };
 1225         -
                        deser.read_list(member, container, |mut list, deser| {
 1226         -
                            list.push(crate::types::ElasticInferenceAcceleratorAssociation::deserialize(deser)?);
 1227         -
                            Ok(list)
 1228         -
                        })?
        1214  +
                        let mut container = Vec::new();
        1215  +
                        deser.read_list(member, &mut |deser| {
        1216  +
                            container.push(crate::types::ElasticInferenceAcceleratorAssociation::deserialize(deser)?);
        1217  +
                            Ok(())
        1218  +
                        })?;
        1219  +
                        container
 1229   1220   
                    });
 1230   1221   
                }
 1231   1222   
                Some(10) => {
 1232   1223   
                    builder.network_interfaces = Some({
 1233         -
                        let container = if let Some(cap) = deser.container_size() {
 1234         -
                            Vec::with_capacity(cap)
 1235         -
                        } else {
 1236         -
                            Vec::new()
 1237         -
                        };
 1238         -
                        deser.read_list(member, container, |mut list, deser| {
 1239         -
                            list.push(crate::types::InstanceNetworkInterface::deserialize(deser)?);
 1240         -
                            Ok(list)
 1241         -
                        })?
        1224  +
                        let mut container = Vec::new();
        1225  +
                        deser.read_list(member, &mut |deser| {
        1226  +
                            container.push(crate::types::InstanceNetworkInterface::deserialize(deser)?);
        1227  +
                            Ok(())
        1228  +
                        })?;
        1229  +
                        container
 1242   1230   
                    });
 1243   1231   
                }
 1244   1232   
                Some(11) => {
 1245   1233   
                    builder.outpost_arn = Some(deser.read_string(member)?);
 1246   1234   
                }
 1247   1235   
                Some(12) => {
 1248   1236   
                    builder.root_device_name = Some(deser.read_string(member)?);
 1249   1237   
                }
 1250   1238   
                Some(13) => {
 1251   1239   
                    builder.root_device_type = Some(crate::types::DeviceType::from(deser.read_string(member)?.as_str()));
 1252   1240   
                }
 1253   1241   
                Some(14) => {
 1254   1242   
                    builder.security_groups = Some({
 1255         -
                        let container = if let Some(cap) = deser.container_size() {
 1256         -
                            Vec::with_capacity(cap)
 1257         -
                        } else {
 1258         -
                            Vec::new()
 1259         -
                        };
 1260         -
                        deser.read_list(member, container, |mut list, deser| {
 1261         -
                            list.push(crate::types::GroupIdentifier::deserialize(deser)?);
 1262         -
                            Ok(list)
 1263         -
                        })?
        1243  +
                        let mut container = Vec::new();
        1244  +
                        deser.read_list(member, &mut |deser| {
        1245  +
                            container.push(crate::types::GroupIdentifier::deserialize(deser)?);
        1246  +
                            Ok(())
        1247  +
                        })?;
        1248  +
                        container
 1264   1249   
                    });
 1265   1250   
                }
 1266   1251   
                Some(15) => {
 1267   1252   
                    builder.source_dest_check = Some(deser.read_boolean(member)?);
 1268   1253   
                }
 1269   1254   
                Some(16) => {
 1270   1255   
                    builder.spot_instance_request_id = Some(deser.read_string(member)?);
 1271   1256   
                }
 1272   1257   
                Some(17) => {
 1273   1258   
                    builder.sriov_net_support = Some(deser.read_string(member)?);
 1274   1259   
                }
 1275   1260   
                Some(18) => {
 1276   1261   
                    builder.state_reason = Some(crate::types::StateReason::deserialize(deser)?);
 1277   1262   
                }
 1278   1263   
                Some(19) => {
 1279   1264   
                    builder.tags = Some({
 1280         -
                        let container = if let Some(cap) = deser.container_size() {
 1281         -
                            Vec::with_capacity(cap)
 1282         -
                        } else {
 1283         -
                            Vec::new()
 1284         -
                        };
 1285         -
                        deser.read_list(member, container, |mut list, deser| {
 1286         -
                            list.push(crate::types::Tag::deserialize(deser)?);
 1287         -
                            Ok(list)
 1288         -
                        })?
        1265  +
                        let mut container = Vec::new();
        1266  +
                        deser.read_list(member, &mut |deser| {
        1267  +
                            container.push(crate::types::Tag::deserialize(deser)?);
        1268  +
                            Ok(())
        1269  +
                        })?;
        1270  +
                        container
 1289   1271   
                    });
 1290   1272   
                }
 1291   1273   
                Some(20) => {
 1292   1274   
                    builder.virtualization_type = Some(crate::types::VirtualizationType::from(deser.read_string(member)?.as_str()));
 1293   1275   
                }
 1294   1276   
                Some(21) => {
 1295   1277   
                    builder.cpu_options = Some(crate::types::CpuOptions::deserialize(deser)?);
 1296   1278   
                }
 1297   1279   
                Some(22) => {
 1298   1280   
                    builder.capacity_block_id = Some(deser.read_string(member)?);
 1299   1281   
                }
 1300   1282   
                Some(23) => {
 1301   1283   
                    builder.capacity_reservation_id = Some(deser.read_string(member)?);
 1302   1284   
                }
 1303   1285   
                Some(24) => {
 1304   1286   
                    builder.capacity_reservation_specification = Some(crate::types::CapacityReservationSpecificationResponse::deserialize(deser)?);
 1305   1287   
                }
 1306   1288   
                Some(25) => {
 1307   1289   
                    builder.hibernation_options = Some(crate::types::HibernationOptions::deserialize(deser)?);
 1308   1290   
                }
 1309   1291   
                Some(26) => {
 1310   1292   
                    builder.licenses = Some({
 1311         -
                        let container = if let Some(cap) = deser.container_size() {
 1312         -
                            Vec::with_capacity(cap)
 1313         -
                        } else {
 1314         -
                            Vec::new()
 1315         -
                        };
 1316         -
                        deser.read_list(member, container, |mut list, deser| {
 1317         -
                            list.push(crate::types::LicenseConfiguration::deserialize(deser)?);
 1318         -
                            Ok(list)
 1319         -
                        })?
        1293  +
                        let mut container = Vec::new();
        1294  +
                        deser.read_list(member, &mut |deser| {
        1295  +
                            container.push(crate::types::LicenseConfiguration::deserialize(deser)?);
        1296  +
                            Ok(())
        1297  +
                        })?;
        1298  +
                        container
 1320   1299   
                    });
 1321   1300   
                }
 1322   1301   
                Some(27) => {
 1323   1302   
                    builder.metadata_options = Some(crate::types::InstanceMetadataOptionsResponse::deserialize(deser)?);
 1324   1303   
                }
 1325   1304   
                Some(28) => {
 1326   1305   
                    builder.enclave_options = Some(crate::types::EnclaveOptions::deserialize(deser)?);
 1327   1306   
                }
 1328   1307   
                Some(29) => {
 1329   1308   
                    builder.boot_mode = Some(crate::types::BootModeValues::from(deser.read_string(member)?.as_str()));
@@ -1357,1336 +1467,1454 @@
 1377   1356   
                    builder.state_transition_reason = Some(deser.read_string(member)?);
 1378   1357   
                }
 1379   1358   
                Some(46) => {
 1380   1359   
                    builder.key_name = Some(deser.read_string(member)?);
 1381   1360   
                }
 1382   1361   
                Some(47) => {
 1383   1362   
                    builder.ami_launch_index = Some(deser.read_integer(member)?);
 1384   1363   
                }
 1385   1364   
                Some(48) => {
 1386   1365   
                    builder.product_codes = Some({
 1387         -
                        let container = if let Some(cap) = deser.container_size() {
 1388         -
                            Vec::with_capacity(cap)
 1389         -
                        } else {
 1390         -
                            Vec::new()
 1391         -
                        };
 1392         -
                        deser.read_list(member, container, |mut list, deser| {
 1393         -
                            list.push(crate::types::ProductCode::deserialize(deser)?);
 1394         -
                            Ok(list)
 1395         -
                        })?
        1366  +
                        let mut container = Vec::new();
        1367  +
                        deser.read_list(member, &mut |deser| {
        1368  +
                            container.push(crate::types::ProductCode::deserialize(deser)?);
        1369  +
                            Ok(())
        1370  +
                        })?;
        1371  +
                        container
 1396   1372   
                    });
 1397   1373   
                }
 1398   1374   
                Some(49) => {
 1399   1375   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
 1400   1376   
                }
 1401   1377   
                Some(50) => {
 1402   1378   
                    builder.launch_time = Some(deser.read_timestamp(member)?);
 1403   1379   
                }
 1404   1380   
                Some(51) => {
 1405   1381   
                    builder.placement = Some(crate::types::Placement::deserialize(deser)?);
 1406   1382   
                }
 1407   1383   
                Some(52) => {
 1408   1384   
                    builder.kernel_id = Some(deser.read_string(member)?);
 1409   1385   
                }
 1410   1386   
                Some(53) => {
 1411   1387   
                    builder.ramdisk_id = Some(deser.read_string(member)?);
 1412   1388   
                }
 1413   1389   
                Some(54) => {
 1414   1390   
                    builder.platform = Some(crate::types::PlatformValues::from(deser.read_string(member)?.as_str()));
 1415   1391   
                }
 1416   1392   
                Some(55) => {
 1417   1393   
                    builder.monitoring = Some(crate::types::Monitoring::deserialize(deser)?);
 1418   1394   
                }
 1419   1395   
                Some(56) => {
 1420   1396   
                    builder.subnet_id = Some(deser.read_string(member)?);
 1421   1397   
                }
 1422   1398   
                Some(57) => {
 1423   1399   
                    builder.vpc_id = Some(deser.read_string(member)?);
 1424   1400   
                }
 1425   1401   
                Some(58) => {
 1426   1402   
                    builder.private_ip_address = Some(deser.read_string(member)?);
 1427   1403   
                }
 1428   1404   
                Some(59) => {
 1429   1405   
                    builder.public_ip_address = Some(deser.read_string(member)?);
 1430   1406   
                }
 1431   1407   
                _ => {}
 1432   1408   
            }
 1433   1409   
            Ok(())
 1434   1410   
        })?;
 1435   1411   
        Ok(builder.build())
 1436   1412   
    }
 1437   1413   
}
        1414  +
impl Instance {
        1415  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        1416  +
    pub fn deserialize_with_response(
        1417  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1418  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        1419  +
        _status: u16,
        1420  +
        _body: &[u8],
        1421  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1422  +
        Self::deserialize(deserializer)
        1423  +
    }
        1424  +
}
 1438   1425   
impl Instance {
 1439   1426   
    /// Creates a new builder-style object to manufacture [`Instance`](crate::types::Instance).
 1440   1427   
    pub fn builder() -> crate::types::builders::InstanceBuilder {
 1441   1428   
        crate::types::builders::InstanceBuilder::default()
 1442   1429   
    }
 1443   1430   
}
 1444   1431   
 1445   1432   
/// A builder for [`Instance`](crate::types::Instance).
 1446   1433   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 1447   1434   
#[non_exhaustive]

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

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

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

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