AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_service_revision_summary.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_service_volume_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_session.rs

@@ -12,12 +145,156 @@
   32     32   
        formatter.field("stream_url", &self.stream_url);
   33     33   
        formatter.field("token_value", &"*** Sensitive Data Redacted ***");
   34     34   
        formatter.finish()
   35     35   
    }
   36     36   
}
   37     37   
static SESSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Session", "com.amazonaws.ecs", "Session");
   39     39   
static SESSION_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Session$sessionId", "com.amazonaws.ecs", "Session"),
   41     41   
    ::aws_smithy_schema::ShapeType::String,
   42         -
    "session_id",
          42  +
    "sessionId",
   43     43   
    0,
   44     44   
);
   45     45   
static SESSION_MEMBER_STREAM_URL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Session$streamUrl", "com.amazonaws.ecs", "Session"),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "stream_url",
          48  +
    "streamUrl",
   49     49   
    1,
   50     50   
);
   51     51   
static SESSION_MEMBER_TOKEN_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Session$tokenValue", "com.amazonaws.ecs", "Session"),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "token_value",
          54  +
    "tokenValue",
   55     55   
    2,
   56     56   
);
   57     57   
static SESSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   58     58   
    SESSION_SCHEMA_ID,
   59     59   
    ::aws_smithy_schema::ShapeType::Structure,
   60     60   
    &[&SESSION_MEMBER_SESSION_ID, &SESSION_MEMBER_STREAM_URL, &SESSION_MEMBER_TOKEN_VALUE],
   61     61   
);
   62     62   
impl Session {
   63     63   
    /// The schema for this shape.
   64     64   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SESSION_SCHEMA;
   65     65   
}
   66     66   
impl ::aws_smithy_schema::serde::SerializableStruct for Session {
   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.session_id {
   73     73   
            ser.write_string(&SESSION_MEMBER_SESSION_ID, val)?;
   74     74   
        }
   75     75   
        if let Some(ref val) = self.stream_url {
   76     76   
            ser.write_string(&SESSION_MEMBER_STREAM_URL, val)?;
   77     77   
        }
   78     78   
        if let Some(ref val) = self.token_value {
   79     79   
            ser.write_string(&SESSION_MEMBER_TOKEN_VALUE, val)?;
   80     80   
        }
   81     81   
        Ok(())
   82     82   
    }
   83     83   
}
   84     84   
impl Session {
   85     85   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   86         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   87         -
        deserializer: &mut D,
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   88     88   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        #[allow(unused_variables, unused_mut)]
   90     90   
        let mut builder = Self::builder();
   91     91   
        #[allow(
   92     92   
            unused_variables,
   93     93   
            unreachable_code,
   94     94   
            clippy::single_match,
   95     95   
            clippy::match_single_binding,
   96     96   
            clippy::diverging_sub_expression
   97     97   
        )]
   98         -
        deserializer.read_struct(&SESSION_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&SESSION_SCHEMA, &mut |member, deser| {
   99     99   
            match member.member_index() {
  100    100   
                Some(0) => {
  101    101   
                    builder.session_id = Some(deser.read_string(member)?);
  102    102   
                }
  103    103   
                Some(1) => {
  104    104   
                    builder.stream_url = Some(deser.read_string(member)?);
  105    105   
                }
  106    106   
                Some(2) => {
  107    107   
                    builder.token_value = Some(deser.read_string(member)?);
  108    108   
                }
  109    109   
                _ => {}
  110    110   
            }
  111    111   
            Ok(())
  112    112   
        })?;
  113    113   
        Ok(builder.build())
  114    114   
    }
  115    115   
}
         116  +
impl Session {
         117  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         118  +
    pub fn deserialize_with_response(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         120  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         121  +
        _status: u16,
         122  +
        _body: &[u8],
         123  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         124  +
        Self::deserialize(deserializer)
         125  +
    }
         126  +
}
  116    127   
impl Session {
  117    128   
    /// Creates a new builder-style object to manufacture [`Session`](crate::types::Session).
  118    129   
    pub fn builder() -> crate::types::builders::SessionBuilder {
  119    130   
        crate::types::builders::SessionBuilder::default()
  120    131   
    }
  121    132   
}
  122    133   
  123    134   
/// A builder for [`Session`](crate::types::Session).
  124    135   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  125    136   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_setting.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_system_control.rs

@@ -56,56 +142,153 @@
   76     76   
            ser.write_string(&SYSTEMCONTROL_MEMBER_NAMESPACE, val)?;
   77     77   
        }
   78     78   
        if let Some(ref val) = self.value {
   79     79   
            ser.write_string(&SYSTEMCONTROL_MEMBER_VALUE, val)?;
   80     80   
        }
   81     81   
        Ok(())
   82     82   
    }
   83     83   
}
   84     84   
impl SystemControl {
   85     85   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   86         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   87         -
        deserializer: &mut D,
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   88     88   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        #[allow(unused_variables, unused_mut)]
   90     90   
        let mut builder = Self::builder();
   91     91   
        #[allow(
   92     92   
            unused_variables,
   93     93   
            unreachable_code,
   94     94   
            clippy::single_match,
   95     95   
            clippy::match_single_binding,
   96     96   
            clippy::diverging_sub_expression
   97     97   
        )]
   98         -
        deserializer.read_struct(&SYSTEMCONTROL_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&SYSTEMCONTROL_SCHEMA, &mut |member, deser| {
   99     99   
            match member.member_index() {
  100    100   
                Some(0) => {
  101    101   
                    builder.namespace = Some(deser.read_string(member)?);
  102    102   
                }
  103    103   
                Some(1) => {
  104    104   
                    builder.value = Some(deser.read_string(member)?);
  105    105   
                }
  106    106   
                _ => {}
  107    107   
            }
  108    108   
            Ok(())
  109    109   
        })?;
  110    110   
        Ok(builder.build())
  111    111   
    }
  112    112   
}
         113  +
impl SystemControl {
         114  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        Self::deserialize(deserializer)
         122  +
    }
         123  +
}
  113    124   
impl SystemControl {
  114    125   
    /// Creates a new builder-style object to manufacture [`SystemControl`](crate::types::SystemControl).
  115    126   
    pub fn builder() -> crate::types::builders::SystemControlBuilder {
  116    127   
        crate::types::builders::SystemControlBuilder::default()
  117    128   
    }
  118    129   
}
  119    130   
  120    131   
/// A builder for [`SystemControl`](crate::types::SystemControl).
  121    132   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  122    133   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_tag.rs

@@ -48,48 +134,145 @@
   68     68   
            ser.write_string(&TAG_MEMBER_KEY, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.value {
   71     71   
            ser.write_string(&TAG_MEMBER_VALUE, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl Tag {
   77     77   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   78         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   79         -
        deserializer: &mut D,
          78  +
    pub fn deserialize(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   80     80   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        #[allow(unused_variables, unused_mut)]
   82     82   
        let mut builder = Self::builder();
   83     83   
        #[allow(
   84     84   
            unused_variables,
   85     85   
            unreachable_code,
   86     86   
            clippy::single_match,
   87     87   
            clippy::match_single_binding,
   88     88   
            clippy::diverging_sub_expression
   89     89   
        )]
   90         -
        deserializer.read_struct(&TAG_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&TAG_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.key = Some(deser.read_string(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.value = Some(deser.read_string(member)?);
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl Tag {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         107  +
    pub fn deserialize_with_response(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         110  +
        _status: u16,
         111  +
        _body: &[u8],
         112  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         113  +
        Self::deserialize(deserializer)
         114  +
    }
         115  +
}
  105    116   
impl Tag {
  106    117   
    /// Creates a new builder-style object to manufacture [`Tag`](crate::types::Tag).
  107    118   
    pub fn builder() -> crate::types::builders::TagBuilder {
  108    119   
        crate::types::builders::TagBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`Tag`](crate::types::Tag).
  113    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  114    125   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task.rs

@@ -315,315 +579,579 @@
  335    335   
);
  336    336   
static TASK_MEMBER_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  337    337   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$attributes", "com.amazonaws.ecs", "Task"),
  338    338   
    ::aws_smithy_schema::ShapeType::List,
  339    339   
    "attributes",
  340    340   
    1,
  341    341   
);
  342    342   
static TASK_MEMBER_AVAILABILITY_ZONE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  343    343   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$availabilityZone", "com.amazonaws.ecs", "Task"),
  344    344   
    ::aws_smithy_schema::ShapeType::String,
  345         -
    "availability_zone",
         345  +
    "availabilityZone",
  346    346   
    2,
  347    347   
);
  348    348   
static TASK_MEMBER_CAPACITY_PROVIDER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  349    349   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$capacityProviderName", "com.amazonaws.ecs", "Task"),
  350    350   
    ::aws_smithy_schema::ShapeType::String,
  351         -
    "capacity_provider_name",
         351  +
    "capacityProviderName",
  352    352   
    3,
  353    353   
);
  354    354   
static TASK_MEMBER_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  355    355   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$clusterArn", "com.amazonaws.ecs", "Task"),
  356    356   
    ::aws_smithy_schema::ShapeType::String,
  357         -
    "cluster_arn",
         357  +
    "clusterArn",
  358    358   
    4,
  359    359   
);
  360    360   
static TASK_MEMBER_CONNECTIVITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  361    361   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$connectivity", "com.amazonaws.ecs", "Task"),
  362    362   
    ::aws_smithy_schema::ShapeType::String,
  363    363   
    "connectivity",
  364    364   
    5,
  365    365   
);
  366    366   
static TASK_MEMBER_CONNECTIVITY_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  367    367   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$connectivityAt", "com.amazonaws.ecs", "Task"),
  368    368   
    ::aws_smithy_schema::ShapeType::Timestamp,
  369         -
    "connectivity_at",
         369  +
    "connectivityAt",
  370    370   
    6,
  371    371   
);
  372    372   
static TASK_MEMBER_CONTAINER_INSTANCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  373    373   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$containerInstanceArn", "com.amazonaws.ecs", "Task"),
  374    374   
    ::aws_smithy_schema::ShapeType::String,
  375         -
    "container_instance_arn",
         375  +
    "containerInstanceArn",
  376    376   
    7,
  377    377   
);
  378    378   
static TASK_MEMBER_CONTAINERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  379    379   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$containers", "com.amazonaws.ecs", "Task"),
  380    380   
    ::aws_smithy_schema::ShapeType::List,
  381    381   
    "containers",
  382    382   
    8,
  383    383   
);
  384    384   
static TASK_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  385    385   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$cpu", "com.amazonaws.ecs", "Task"),
  386    386   
    ::aws_smithy_schema::ShapeType::String,
  387    387   
    "cpu",
  388    388   
    9,
  389    389   
);
  390    390   
static TASK_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  391    391   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$createdAt", "com.amazonaws.ecs", "Task"),
  392    392   
    ::aws_smithy_schema::ShapeType::Timestamp,
  393         -
    "created_at",
         393  +
    "createdAt",
  394    394   
    10,
  395    395   
);
  396    396   
static TASK_MEMBER_DESIRED_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  397    397   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$desiredStatus", "com.amazonaws.ecs", "Task"),
  398    398   
    ::aws_smithy_schema::ShapeType::String,
  399         -
    "desired_status",
         399  +
    "desiredStatus",
  400    400   
    11,
  401    401   
);
  402    402   
static TASK_MEMBER_ENABLE_EXECUTE_COMMAND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  403    403   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$enableExecuteCommand", "com.amazonaws.ecs", "Task"),
  404    404   
    ::aws_smithy_schema::ShapeType::Boolean,
  405         -
    "enable_execute_command",
         405  +
    "enableExecuteCommand",
  406    406   
    12,
  407    407   
);
  408    408   
static TASK_MEMBER_EXECUTION_STOPPED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  409    409   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$executionStoppedAt", "com.amazonaws.ecs", "Task"),
  410    410   
    ::aws_smithy_schema::ShapeType::Timestamp,
  411         -
    "execution_stopped_at",
         411  +
    "executionStoppedAt",
  412    412   
    13,
  413    413   
);
  414    414   
static TASK_MEMBER_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  415    415   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$group", "com.amazonaws.ecs", "Task"),
  416    416   
    ::aws_smithy_schema::ShapeType::String,
  417    417   
    "group",
  418    418   
    14,
  419    419   
);
  420    420   
static TASK_MEMBER_HEALTH_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  421    421   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$healthStatus", "com.amazonaws.ecs", "Task"),
  422    422   
    ::aws_smithy_schema::ShapeType::String,
  423         -
    "health_status",
         423  +
    "healthStatus",
  424    424   
    15,
  425    425   
);
  426    426   
static TASK_MEMBER_INFERENCE_ACCELERATORS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  427    427   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$inferenceAccelerators", "com.amazonaws.ecs", "Task"),
  428    428   
    ::aws_smithy_schema::ShapeType::List,
  429         -
    "inference_accelerators",
         429  +
    "inferenceAccelerators",
  430    430   
    16,
  431    431   
);
  432    432   
static TASK_MEMBER_LAST_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  433    433   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$lastStatus", "com.amazonaws.ecs", "Task"),
  434    434   
    ::aws_smithy_schema::ShapeType::String,
  435         -
    "last_status",
         435  +
    "lastStatus",
  436    436   
    17,
  437    437   
);
  438    438   
static TASK_MEMBER_LAUNCH_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  439    439   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$launchType", "com.amazonaws.ecs", "Task"),
  440    440   
    ::aws_smithy_schema::ShapeType::String,
  441         -
    "launch_type",
         441  +
    "launchType",
  442    442   
    18,
  443    443   
);
  444    444   
static TASK_MEMBER_MEMORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  445    445   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$memory", "com.amazonaws.ecs", "Task"),
  446    446   
    ::aws_smithy_schema::ShapeType::String,
  447    447   
    "memory",
  448    448   
    19,
  449    449   
);
  450    450   
static TASK_MEMBER_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  451    451   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$overrides", "com.amazonaws.ecs", "Task"),
  452    452   
    ::aws_smithy_schema::ShapeType::Structure,
  453    453   
    "overrides",
  454    454   
    20,
  455    455   
);
  456    456   
static TASK_MEMBER_PLATFORM_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  457    457   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$platformVersion", "com.amazonaws.ecs", "Task"),
  458    458   
    ::aws_smithy_schema::ShapeType::String,
  459         -
    "platform_version",
         459  +
    "platformVersion",
  460    460   
    21,
  461    461   
);
  462    462   
static TASK_MEMBER_PLATFORM_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  463    463   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$platformFamily", "com.amazonaws.ecs", "Task"),
  464    464   
    ::aws_smithy_schema::ShapeType::String,
  465         -
    "platform_family",
         465  +
    "platformFamily",
  466    466   
    22,
  467    467   
);
  468    468   
static TASK_MEMBER_PULL_STARTED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  469    469   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$pullStartedAt", "com.amazonaws.ecs", "Task"),
  470    470   
    ::aws_smithy_schema::ShapeType::Timestamp,
  471         -
    "pull_started_at",
         471  +
    "pullStartedAt",
  472    472   
    23,
  473    473   
);
  474    474   
static TASK_MEMBER_PULL_STOPPED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  475    475   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$pullStoppedAt", "com.amazonaws.ecs", "Task"),
  476    476   
    ::aws_smithy_schema::ShapeType::Timestamp,
  477         -
    "pull_stopped_at",
         477  +
    "pullStoppedAt",
  478    478   
    24,
  479    479   
);
  480    480   
static TASK_MEMBER_STARTED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  481    481   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$startedAt", "com.amazonaws.ecs", "Task"),
  482    482   
    ::aws_smithy_schema::ShapeType::Timestamp,
  483         -
    "started_at",
         483  +
    "startedAt",
  484    484   
    25,
  485    485   
);
  486    486   
static TASK_MEMBER_STARTED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  487    487   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$startedBy", "com.amazonaws.ecs", "Task"),
  488    488   
    ::aws_smithy_schema::ShapeType::String,
  489         -
    "started_by",
         489  +
    "startedBy",
  490    490   
    26,
  491    491   
);
  492    492   
static TASK_MEMBER_STOP_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  493    493   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$stopCode", "com.amazonaws.ecs", "Task"),
  494    494   
    ::aws_smithy_schema::ShapeType::String,
  495         -
    "stop_code",
         495  +
    "stopCode",
  496    496   
    27,
  497    497   
);
  498    498   
static TASK_MEMBER_STOPPED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  499    499   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$stoppedAt", "com.amazonaws.ecs", "Task"),
  500    500   
    ::aws_smithy_schema::ShapeType::Timestamp,
  501         -
    "stopped_at",
         501  +
    "stoppedAt",
  502    502   
    28,
  503    503   
);
  504    504   
static TASK_MEMBER_STOPPED_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  505    505   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$stoppedReason", "com.amazonaws.ecs", "Task"),
  506    506   
    ::aws_smithy_schema::ShapeType::String,
  507         -
    "stopped_reason",
         507  +
    "stoppedReason",
  508    508   
    29,
  509    509   
);
  510    510   
static TASK_MEMBER_STOPPING_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  511    511   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$stoppingAt", "com.amazonaws.ecs", "Task"),
  512    512   
    ::aws_smithy_schema::ShapeType::Timestamp,
  513         -
    "stopping_at",
         513  +
    "stoppingAt",
  514    514   
    30,
  515    515   
);
  516    516   
static TASK_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  517    517   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$tags", "com.amazonaws.ecs", "Task"),
  518    518   
    ::aws_smithy_schema::ShapeType::List,
  519    519   
    "tags",
  520    520   
    31,
  521    521   
);
  522    522   
static TASK_MEMBER_TASK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  523    523   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$taskArn", "com.amazonaws.ecs", "Task"),
  524    524   
    ::aws_smithy_schema::ShapeType::String,
  525         -
    "task_arn",
         525  +
    "taskArn",
  526    526   
    32,
  527    527   
);
  528    528   
static TASK_MEMBER_TASK_DEFINITION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  529    529   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$taskDefinitionArn", "com.amazonaws.ecs", "Task"),
  530    530   
    ::aws_smithy_schema::ShapeType::String,
  531         -
    "task_definition_arn",
         531  +
    "taskDefinitionArn",
  532    532   
    33,
  533    533   
);
  534    534   
static TASK_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  535    535   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$version", "com.amazonaws.ecs", "Task"),
  536    536   
    ::aws_smithy_schema::ShapeType::Long,
  537    537   
    "version",
  538    538   
    34,
  539    539   
);
  540    540   
static TASK_MEMBER_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  541    541   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$ephemeralStorage", "com.amazonaws.ecs", "Task"),
  542    542   
    ::aws_smithy_schema::ShapeType::Structure,
  543         -
    "ephemeral_storage",
         543  +
    "ephemeralStorage",
  544    544   
    35,
  545    545   
);
  546    546   
static TASK_MEMBER_FARGATE_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  547    547   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Task$fargateEphemeralStorage", "com.amazonaws.ecs", "Task"),
  548    548   
    ::aws_smithy_schema::ShapeType::Structure,
  549         -
    "fargate_ephemeral_storage",
         549  +
    "fargateEphemeralStorage",
  550    550   
    36,
  551    551   
);
  552    552   
static TASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  553    553   
    TASK_SCHEMA_ID,
  554    554   
    ::aws_smithy_schema::ShapeType::Structure,
  555    555   
    &[
  556    556   
        &TASK_MEMBER_ATTACHMENTS,
  557    557   
        &TASK_MEMBER_ATTRIBUTES,
  558    558   
        &TASK_MEMBER_AVAILABILITY_ZONE,
  559    559   
        &TASK_MEMBER_CAPACITY_PROVIDER_NAME,
@@ -721,721 +962,958 @@
  741    741   
            ser.write_struct(&TASK_MEMBER_EPHEMERAL_STORAGE, val)?;
  742    742   
        }
  743    743   
        if let Some(ref val) = self.fargate_ephemeral_storage {
  744    744   
            ser.write_struct(&TASK_MEMBER_FARGATE_EPHEMERAL_STORAGE, val)?;
  745    745   
        }
  746    746   
        Ok(())
  747    747   
    }
  748    748   
}
  749    749   
impl Task {
  750    750   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  751         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  752         -
        deserializer: &mut D,
         751  +
    pub fn deserialize(
         752  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  753    753   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  754    754   
        #[allow(unused_variables, unused_mut)]
  755    755   
        let mut builder = Self::builder();
  756    756   
        #[allow(
  757    757   
            unused_variables,
  758    758   
            unreachable_code,
  759    759   
            clippy::single_match,
  760    760   
            clippy::match_single_binding,
  761    761   
            clippy::diverging_sub_expression
  762    762   
        )]
  763         -
        deserializer.read_struct(&TASK_SCHEMA, (), |_, member, deser| {
         763  +
        deserializer.read_struct(&TASK_SCHEMA, &mut |member, deser| {
  764    764   
            match member.member_index() {
  765    765   
                Some(0) => {
  766    766   
                    builder.attachments = Some({
  767         -
                        let container = if let Some(cap) = deser.container_size() {
  768         -
                            Vec::with_capacity(cap)
  769         -
                        } else {
  770         -
                            Vec::new()
  771         -
                        };
  772         -
                        deser.read_list(member, container, |mut list, deser| {
  773         -
                            list.push(crate::types::Attachment::deserialize(deser)?);
  774         -
                            Ok(list)
  775         -
                        })?
         767  +
                        let mut container = Vec::new();
         768  +
                        deser.read_list(member, &mut |deser| {
         769  +
                            container.push(crate::types::Attachment::deserialize(deser)?);
         770  +
                            Ok(())
         771  +
                        })?;
         772  +
                        container
  776    773   
                    });
  777    774   
                }
  778    775   
                Some(1) => {
  779    776   
                    builder.attributes = Some({
  780         -
                        let container = if let Some(cap) = deser.container_size() {
  781         -
                            Vec::with_capacity(cap)
  782         -
                        } else {
  783         -
                            Vec::new()
  784         -
                        };
  785         -
                        deser.read_list(member, container, |mut list, deser| {
  786         -
                            list.push(crate::types::Attribute::deserialize(deser)?);
  787         -
                            Ok(list)
  788         -
                        })?
         777  +
                        let mut container = Vec::new();
         778  +
                        deser.read_list(member, &mut |deser| {
         779  +
                            container.push(crate::types::Attribute::deserialize(deser)?);
         780  +
                            Ok(())
         781  +
                        })?;
         782  +
                        container
  789    783   
                    });
  790    784   
                }
  791    785   
                Some(2) => {
  792    786   
                    builder.availability_zone = Some(deser.read_string(member)?);
  793    787   
                }
  794    788   
                Some(3) => {
  795    789   
                    builder.capacity_provider_name = Some(deser.read_string(member)?);
  796    790   
                }
  797    791   
                Some(4) => {
  798    792   
                    builder.cluster_arn = Some(deser.read_string(member)?);
  799    793   
                }
  800    794   
                Some(5) => {
  801    795   
                    builder.connectivity = Some(crate::types::Connectivity::from(deser.read_string(member)?.as_str()));
  802    796   
                }
  803    797   
                Some(6) => {
  804    798   
                    builder.connectivity_at = Some(deser.read_timestamp(member)?);
  805    799   
                }
  806    800   
                Some(7) => {
  807    801   
                    builder.container_instance_arn = Some(deser.read_string(member)?);
  808    802   
                }
  809    803   
                Some(8) => {
  810    804   
                    builder.containers = Some({
  811         -
                        let container = if let Some(cap) = deser.container_size() {
  812         -
                            Vec::with_capacity(cap)
  813         -
                        } else {
  814         -
                            Vec::new()
  815         -
                        };
  816         -
                        deser.read_list(member, container, |mut list, deser| {
  817         -
                            list.push(crate::types::Container::deserialize(deser)?);
  818         -
                            Ok(list)
  819         -
                        })?
         805  +
                        let mut container = Vec::new();
         806  +
                        deser.read_list(member, &mut |deser| {
         807  +
                            container.push(crate::types::Container::deserialize(deser)?);
         808  +
                            Ok(())
         809  +
                        })?;
         810  +
                        container
  820    811   
                    });
  821    812   
                }
  822    813   
                Some(9) => {
  823    814   
                    builder.cpu = Some(deser.read_string(member)?);
  824    815   
                }
  825    816   
                Some(10) => {
  826    817   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  827    818   
                }
  828    819   
                Some(11) => {
  829    820   
                    builder.desired_status = Some(deser.read_string(member)?);
  830    821   
                }
  831    822   
                Some(12) => {
  832    823   
                    builder.enable_execute_command = Some(deser.read_boolean(member)?);
  833    824   
                }
  834    825   
                Some(13) => {
  835    826   
                    builder.execution_stopped_at = Some(deser.read_timestamp(member)?);
  836    827   
                }
  837    828   
                Some(14) => {
  838    829   
                    builder.group = Some(deser.read_string(member)?);
  839    830   
                }
  840    831   
                Some(15) => {
  841    832   
                    builder.health_status = Some(crate::types::HealthStatus::from(deser.read_string(member)?.as_str()));
  842    833   
                }
  843    834   
                Some(16) => {
  844    835   
                    builder.inference_accelerators = Some({
  845         -
                        let container = if let Some(cap) = deser.container_size() {
  846         -
                            Vec::with_capacity(cap)
  847         -
                        } else {
  848         -
                            Vec::new()
  849         -
                        };
  850         -
                        deser.read_list(member, container, |mut list, deser| {
  851         -
                            list.push(crate::types::InferenceAccelerator::deserialize(deser)?);
  852         -
                            Ok(list)
  853         -
                        })?
         836  +
                        let mut container = Vec::new();
         837  +
                        deser.read_list(member, &mut |deser| {
         838  +
                            container.push(crate::types::InferenceAccelerator::deserialize(deser)?);
         839  +
                            Ok(())
         840  +
                        })?;
         841  +
                        container
  854    842   
                    });
  855    843   
                }
  856    844   
                Some(17) => {
  857    845   
                    builder.last_status = Some(deser.read_string(member)?);
  858    846   
                }
  859    847   
                Some(18) => {
  860    848   
                    builder.launch_type = Some(crate::types::LaunchType::from(deser.read_string(member)?.as_str()));
  861    849   
                }
  862    850   
                Some(19) => {
  863    851   
                    builder.memory = Some(deser.read_string(member)?);
  864    852   
                }
  865    853   
                Some(20) => {
  866    854   
                    builder.overrides = Some(crate::types::TaskOverride::deserialize(deser)?);
  867    855   
                }
  868    856   
                Some(21) => {
  869    857   
                    builder.platform_version = Some(deser.read_string(member)?);
  870    858   
                }
  871    859   
                Some(22) => {
  872    860   
                    builder.platform_family = Some(deser.read_string(member)?);
  873    861   
                }
  874    862   
                Some(23) => {
  875    863   
                    builder.pull_started_at = Some(deser.read_timestamp(member)?);
  876    864   
                }
  877    865   
                Some(24) => {
  878    866   
                    builder.pull_stopped_at = Some(deser.read_timestamp(member)?);
  879    867   
                }
  880    868   
                Some(25) => {
  881    869   
                    builder.started_at = Some(deser.read_timestamp(member)?);
  882    870   
                }
  883    871   
                Some(26) => {
  884    872   
                    builder.started_by = Some(deser.read_string(member)?);
  885    873   
                }
  886    874   
                Some(27) => {
  887    875   
                    builder.stop_code = Some(crate::types::TaskStopCode::from(deser.read_string(member)?.as_str()));
  888    876   
                }
  889    877   
                Some(28) => {
  890    878   
                    builder.stopped_at = Some(deser.read_timestamp(member)?);
  891    879   
                }
  892    880   
                Some(29) => {
  893    881   
                    builder.stopped_reason = Some(deser.read_string(member)?);
  894    882   
                }
  895    883   
                Some(30) => {
  896    884   
                    builder.stopping_at = Some(deser.read_timestamp(member)?);
  897    885   
                }
  898    886   
                Some(31) => {
  899    887   
                    builder.tags = Some({
  900         -
                        let container = if let Some(cap) = deser.container_size() {
  901         -
                            Vec::with_capacity(cap)
  902         -
                        } else {
  903         -
                            Vec::new()
  904         -
                        };
  905         -
                        deser.read_list(member, container, |mut list, deser| {
  906         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  907         -
                            Ok(list)
  908         -
                        })?
         888  +
                        let mut container = Vec::new();
         889  +
                        deser.read_list(member, &mut |deser| {
         890  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         891  +
                            Ok(())
         892  +
                        })?;
         893  +
                        container
  909    894   
                    });
  910    895   
                }
  911    896   
                Some(32) => {
  912    897   
                    builder.task_arn = Some(deser.read_string(member)?);
  913    898   
                }
  914    899   
                Some(33) => {
  915    900   
                    builder.task_definition_arn = Some(deser.read_string(member)?);
  916    901   
                }
  917    902   
                Some(34) => {
  918    903   
                    builder.version = Some(deser.read_long(member)?);
  919    904   
                }
  920    905   
                Some(35) => {
  921    906   
                    builder.ephemeral_storage = Some(crate::types::EphemeralStorage::deserialize(deser)?);
  922    907   
                }
  923    908   
                Some(36) => {
  924    909   
                    builder.fargate_ephemeral_storage = Some(crate::types::TaskEphemeralStorage::deserialize(deser)?);
  925    910   
                }
  926    911   
                _ => {}
  927    912   
            }
  928    913   
            Ok(())
  929    914   
        })?;
  930    915   
        Ok(builder.build())
  931    916   
    }
  932    917   
}
         918  +
impl Task {
         919  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         920  +
    pub fn deserialize_with_response(
         921  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         922  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         923  +
        _status: u16,
         924  +
        _body: &[u8],
         925  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         926  +
        Self::deserialize(deserializer)
         927  +
    }
         928  +
}
  933    929   
impl Task {
  934    930   
    /// Creates a new builder-style object to manufacture [`Task`](crate::types::Task).
  935    931   
    pub fn builder() -> crate::types::builders::TaskBuilder {
  936    932   
        crate::types::builders::TaskBuilder::default()
  937    933   
    }
  938    934   
}
  939    935   
  940    936   
/// A builder for [`Task`](crate::types::Task).
  941    937   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  942    938   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_definition.rs

@@ -263,263 +495,495 @@
  283    283   
}
  284    284   
static TASKDEFINITION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  285    285   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition", "com.amazonaws.ecs", "TaskDefinition");
  286    286   
static TASKDEFINITION_MEMBER_TASK_DEFINITION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  287    287   
    ::aws_smithy_schema::ShapeId::from_static(
  288    288   
        "com.amazonaws.ecs#TaskDefinition$taskDefinitionArn",
  289    289   
        "com.amazonaws.ecs",
  290    290   
        "TaskDefinition",
  291    291   
    ),
  292    292   
    ::aws_smithy_schema::ShapeType::String,
  293         -
    "task_definition_arn",
         293  +
    "taskDefinitionArn",
  294    294   
    0,
  295    295   
);
  296    296   
static TASKDEFINITION_MEMBER_CONTAINER_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  297    297   
    ::aws_smithy_schema::ShapeId::from_static(
  298    298   
        "com.amazonaws.ecs#TaskDefinition$containerDefinitions",
  299    299   
        "com.amazonaws.ecs",
  300    300   
        "TaskDefinition",
  301    301   
    ),
  302    302   
    ::aws_smithy_schema::ShapeType::List,
  303         -
    "container_definitions",
         303  +
    "containerDefinitions",
  304    304   
    1,
  305    305   
);
  306    306   
static TASKDEFINITION_MEMBER_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  307    307   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$family", "com.amazonaws.ecs", "TaskDefinition"),
  308    308   
    ::aws_smithy_schema::ShapeType::String,
  309    309   
    "family",
  310    310   
    2,
  311    311   
);
  312    312   
static TASKDEFINITION_MEMBER_TASK_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  313    313   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$taskRoleArn", "com.amazonaws.ecs", "TaskDefinition"),
  314    314   
    ::aws_smithy_schema::ShapeType::String,
  315         -
    "task_role_arn",
         315  +
    "taskRoleArn",
  316    316   
    3,
  317    317   
);
  318    318   
static TASKDEFINITION_MEMBER_EXECUTION_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  319    319   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$executionRoleArn", "com.amazonaws.ecs", "TaskDefinition"),
  320    320   
    ::aws_smithy_schema::ShapeType::String,
  321         -
    "execution_role_arn",
         321  +
    "executionRoleArn",
  322    322   
    4,
  323    323   
);
  324    324   
static TASKDEFINITION_MEMBER_NETWORK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  325    325   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$networkMode", "com.amazonaws.ecs", "TaskDefinition"),
  326    326   
    ::aws_smithy_schema::ShapeType::String,
  327         -
    "network_mode",
         327  +
    "networkMode",
  328    328   
    5,
  329    329   
);
  330    330   
static TASKDEFINITION_MEMBER_REVISION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  331    331   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$revision", "com.amazonaws.ecs", "TaskDefinition"),
  332    332   
    ::aws_smithy_schema::ShapeType::Integer,
  333    333   
    "revision",
  334    334   
    6,
  335    335   
);
  336    336   
static TASKDEFINITION_MEMBER_VOLUMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  337    337   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$volumes", "com.amazonaws.ecs", "TaskDefinition"),
  338    338   
    ::aws_smithy_schema::ShapeType::List,
  339    339   
    "volumes",
  340    340   
    7,
  341    341   
);
  342    342   
static TASKDEFINITION_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  343    343   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$status", "com.amazonaws.ecs", "TaskDefinition"),
  344    344   
    ::aws_smithy_schema::ShapeType::String,
  345    345   
    "status",
  346    346   
    8,
  347    347   
);
  348    348   
static TASKDEFINITION_MEMBER_REQUIRES_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  349    349   
    ::aws_smithy_schema::ShapeId::from_static(
  350    350   
        "com.amazonaws.ecs#TaskDefinition$requiresAttributes",
  351    351   
        "com.amazonaws.ecs",
  352    352   
        "TaskDefinition",
  353    353   
    ),
  354    354   
    ::aws_smithy_schema::ShapeType::List,
  355         -
    "requires_attributes",
         355  +
    "requiresAttributes",
  356    356   
    9,
  357    357   
);
  358    358   
static TASKDEFINITION_MEMBER_PLACEMENT_CONSTRAINTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  359    359   
    ::aws_smithy_schema::ShapeId::from_static(
  360    360   
        "com.amazonaws.ecs#TaskDefinition$placementConstraints",
  361    361   
        "com.amazonaws.ecs",
  362    362   
        "TaskDefinition",
  363    363   
    ),
  364    364   
    ::aws_smithy_schema::ShapeType::List,
  365         -
    "placement_constraints",
         365  +
    "placementConstraints",
  366    366   
    10,
  367    367   
);
  368    368   
static TASKDEFINITION_MEMBER_COMPATIBILITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  369    369   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$compatibilities", "com.amazonaws.ecs", "TaskDefinition"),
  370    370   
    ::aws_smithy_schema::ShapeType::List,
  371    371   
    "compatibilities",
  372    372   
    11,
  373    373   
);
  374    374   
static TASKDEFINITION_MEMBER_RUNTIME_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  375    375   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$runtimePlatform", "com.amazonaws.ecs", "TaskDefinition"),
  376    376   
    ::aws_smithy_schema::ShapeType::Structure,
  377         -
    "runtime_platform",
         377  +
    "runtimePlatform",
  378    378   
    12,
  379    379   
);
  380    380   
static TASKDEFINITION_MEMBER_REQUIRES_COMPATIBILITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  381    381   
    ::aws_smithy_schema::ShapeId::from_static(
  382    382   
        "com.amazonaws.ecs#TaskDefinition$requiresCompatibilities",
  383    383   
        "com.amazonaws.ecs",
  384    384   
        "TaskDefinition",
  385    385   
    ),
  386    386   
    ::aws_smithy_schema::ShapeType::List,
  387         -
    "requires_compatibilities",
         387  +
    "requiresCompatibilities",
  388    388   
    13,
  389    389   
);
  390    390   
static TASKDEFINITION_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  391    391   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$cpu", "com.amazonaws.ecs", "TaskDefinition"),
  392    392   
    ::aws_smithy_schema::ShapeType::String,
  393    393   
    "cpu",
  394    394   
    14,
  395    395   
);
  396    396   
static TASKDEFINITION_MEMBER_MEMORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  397    397   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$memory", "com.amazonaws.ecs", "TaskDefinition"),
  398    398   
    ::aws_smithy_schema::ShapeType::String,
  399    399   
    "memory",
  400    400   
    15,
  401    401   
);
  402    402   
static TASKDEFINITION_MEMBER_INFERENCE_ACCELERATORS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  403    403   
    ::aws_smithy_schema::ShapeId::from_static(
  404    404   
        "com.amazonaws.ecs#TaskDefinition$inferenceAccelerators",
  405    405   
        "com.amazonaws.ecs",
  406    406   
        "TaskDefinition",
  407    407   
    ),
  408    408   
    ::aws_smithy_schema::ShapeType::List,
  409         -
    "inference_accelerators",
         409  +
    "inferenceAccelerators",
  410    410   
    16,
  411    411   
);
  412    412   
static TASKDEFINITION_MEMBER_PID_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  413    413   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$pidMode", "com.amazonaws.ecs", "TaskDefinition"),
  414    414   
    ::aws_smithy_schema::ShapeType::String,
  415         -
    "pid_mode",
         415  +
    "pidMode",
  416    416   
    17,
  417    417   
);
  418    418   
static TASKDEFINITION_MEMBER_IPC_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  419    419   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$ipcMode", "com.amazonaws.ecs", "TaskDefinition"),
  420    420   
    ::aws_smithy_schema::ShapeType::String,
  421         -
    "ipc_mode",
         421  +
    "ipcMode",
  422    422   
    18,
  423    423   
);
  424    424   
static TASKDEFINITION_MEMBER_PROXY_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  425    425   
    ::aws_smithy_schema::ShapeId::from_static(
  426    426   
        "com.amazonaws.ecs#TaskDefinition$proxyConfiguration",
  427    427   
        "com.amazonaws.ecs",
  428    428   
        "TaskDefinition",
  429    429   
    ),
  430    430   
    ::aws_smithy_schema::ShapeType::Structure,
  431         -
    "proxy_configuration",
         431  +
    "proxyConfiguration",
  432    432   
    19,
  433    433   
);
  434    434   
static TASKDEFINITION_MEMBER_REGISTERED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  435    435   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$registeredAt", "com.amazonaws.ecs", "TaskDefinition"),
  436    436   
    ::aws_smithy_schema::ShapeType::Timestamp,
  437         -
    "registered_at",
         437  +
    "registeredAt",
  438    438   
    20,
  439    439   
);
  440    440   
static TASKDEFINITION_MEMBER_DEREGISTERED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  441    441   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$deregisteredAt", "com.amazonaws.ecs", "TaskDefinition"),
  442    442   
    ::aws_smithy_schema::ShapeType::Timestamp,
  443         -
    "deregistered_at",
         443  +
    "deregisteredAt",
  444    444   
    21,
  445    445   
);
  446    446   
static TASKDEFINITION_MEMBER_REGISTERED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  447    447   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$registeredBy", "com.amazonaws.ecs", "TaskDefinition"),
  448    448   
    ::aws_smithy_schema::ShapeType::String,
  449         -
    "registered_by",
         449  +
    "registeredBy",
  450    450   
    22,
  451    451   
);
  452    452   
static TASKDEFINITION_MEMBER_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  453    453   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskDefinition$ephemeralStorage", "com.amazonaws.ecs", "TaskDefinition"),
  454    454   
    ::aws_smithy_schema::ShapeType::Structure,
  455         -
    "ephemeral_storage",
         455  +
    "ephemeralStorage",
  456    456   
    23,
  457    457   
);
  458    458   
static TASKDEFINITION_MEMBER_ENABLE_FAULT_INJECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  459    459   
    ::aws_smithy_schema::ShapeId::from_static(
  460    460   
        "com.amazonaws.ecs#TaskDefinition$enableFaultInjection",
  461    461   
        "com.amazonaws.ecs",
  462    462   
        "TaskDefinition",
  463    463   
    ),
  464    464   
    ::aws_smithy_schema::ShapeType::Boolean,
  465         -
    "enable_fault_injection",
         465  +
    "enableFaultInjection",
  466    466   
    24,
  467    467   
);
  468    468   
static TASKDEFINITION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  469    469   
    TASKDEFINITION_SCHEMA_ID,
  470    470   
    ::aws_smithy_schema::ShapeType::Structure,
  471    471   
    &[
  472    472   
        &TASKDEFINITION_MEMBER_TASK_DEFINITION_ARN,
  473    473   
        &TASKDEFINITION_MEMBER_CONTAINER_DEFINITIONS,
  474    474   
        &TASKDEFINITION_MEMBER_FAMILY,
  475    475   
        &TASKDEFINITION_MEMBER_TASK_ROLE_ARN,
@@ -616,616 +841,831 @@
  636    636   
            ser.write_struct(&TASKDEFINITION_MEMBER_EPHEMERAL_STORAGE, val)?;
  637    637   
        }
  638    638   
        if let Some(ref val) = self.enable_fault_injection {
  639    639   
            ser.write_boolean(&TASKDEFINITION_MEMBER_ENABLE_FAULT_INJECTION, *val)?;
  640    640   
        }
  641    641   
        Ok(())
  642    642   
    }
  643    643   
}
  644    644   
impl TaskDefinition {
  645    645   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  646         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  647         -
        deserializer: &mut D,
         646  +
    pub fn deserialize(
         647  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  648    648   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  649    649   
        #[allow(unused_variables, unused_mut)]
  650    650   
        let mut builder = Self::builder();
  651    651   
        #[allow(
  652    652   
            unused_variables,
  653    653   
            unreachable_code,
  654    654   
            clippy::single_match,
  655    655   
            clippy::match_single_binding,
  656    656   
            clippy::diverging_sub_expression
  657    657   
        )]
  658         -
        deserializer.read_struct(&TASKDEFINITION_SCHEMA, (), |_, member, deser| {
         658  +
        deserializer.read_struct(&TASKDEFINITION_SCHEMA, &mut |member, deser| {
  659    659   
            match member.member_index() {
  660    660   
                Some(0) => {
  661    661   
                    builder.task_definition_arn = Some(deser.read_string(member)?);
  662    662   
                }
  663    663   
                Some(1) => {
  664    664   
                    builder.container_definitions = Some({
  665         -
                        let container = if let Some(cap) = deser.container_size() {
  666         -
                            Vec::with_capacity(cap)
  667         -
                        } else {
  668         -
                            Vec::new()
  669         -
                        };
  670         -
                        deser.read_list(member, container, |mut list, deser| {
  671         -
                            list.push(crate::types::ContainerDefinition::deserialize(deser)?);
  672         -
                            Ok(list)
  673         -
                        })?
         665  +
                        let mut container = Vec::new();
         666  +
                        deser.read_list(member, &mut |deser| {
         667  +
                            container.push(crate::types::ContainerDefinition::deserialize(deser)?);
         668  +
                            Ok(())
         669  +
                        })?;
         670  +
                        container
  674    671   
                    });
  675    672   
                }
  676    673   
                Some(2) => {
  677    674   
                    builder.family = Some(deser.read_string(member)?);
  678    675   
                }
  679    676   
                Some(3) => {
  680    677   
                    builder.task_role_arn = Some(deser.read_string(member)?);
  681    678   
                }
  682    679   
                Some(4) => {
  683    680   
                    builder.execution_role_arn = Some(deser.read_string(member)?);
  684    681   
                }
  685    682   
                Some(5) => {
  686    683   
                    builder.network_mode = Some(crate::types::NetworkMode::from(deser.read_string(member)?.as_str()));
  687    684   
                }
  688    685   
                Some(6) => {
  689    686   
                    builder.revision = Some(deser.read_integer(member)?);
  690    687   
                }
  691    688   
                Some(7) => {
  692    689   
                    builder.volumes = Some({
  693         -
                        let container = if let Some(cap) = deser.container_size() {
  694         -
                            Vec::with_capacity(cap)
  695         -
                        } else {
  696         -
                            Vec::new()
  697         -
                        };
  698         -
                        deser.read_list(member, container, |mut list, deser| {
  699         -
                            list.push(crate::types::Volume::deserialize(deser)?);
  700         -
                            Ok(list)
  701         -
                        })?
         690  +
                        let mut container = Vec::new();
         691  +
                        deser.read_list(member, &mut |deser| {
         692  +
                            container.push(crate::types::Volume::deserialize(deser)?);
         693  +
                            Ok(())
         694  +
                        })?;
         695  +
                        container
  702    696   
                    });
  703    697   
                }
  704    698   
                Some(8) => {
  705    699   
                    builder.status = Some(crate::types::TaskDefinitionStatus::from(deser.read_string(member)?.as_str()));
  706    700   
                }
  707    701   
                Some(9) => {
  708    702   
                    builder.requires_attributes = Some({
  709         -
                        let container = if let Some(cap) = deser.container_size() {
  710         -
                            Vec::with_capacity(cap)
  711         -
                        } else {
  712         -
                            Vec::new()
  713         -
                        };
  714         -
                        deser.read_list(member, container, |mut list, deser| {
  715         -
                            list.push(crate::types::Attribute::deserialize(deser)?);
  716         -
                            Ok(list)
  717         -
                        })?
         703  +
                        let mut container = Vec::new();
         704  +
                        deser.read_list(member, &mut |deser| {
         705  +
                            container.push(crate::types::Attribute::deserialize(deser)?);
         706  +
                            Ok(())
         707  +
                        })?;
         708  +
                        container
  718    709   
                    });
  719    710   
                }
  720    711   
                Some(10) => {
  721    712   
                    builder.placement_constraints = Some({
  722         -
                        let container = if let Some(cap) = deser.container_size() {
  723         -
                            Vec::with_capacity(cap)
  724         -
                        } else {
  725         -
                            Vec::new()
  726         -
                        };
  727         -
                        deser.read_list(member, container, |mut list, deser| {
  728         -
                            list.push(crate::types::TaskDefinitionPlacementConstraint::deserialize(deser)?);
  729         -
                            Ok(list)
  730         -
                        })?
         713  +
                        let mut container = Vec::new();
         714  +
                        deser.read_list(member, &mut |deser| {
         715  +
                            container.push(crate::types::TaskDefinitionPlacementConstraint::deserialize(deser)?);
         716  +
                            Ok(())
         717  +
                        })?;
         718  +
                        container
  731    719   
                    });
  732    720   
                }
  733    721   
                Some(11) => {
  734    722   
                    builder.compatibilities = Some({
  735         -
                        let container = if let Some(cap) = deser.container_size() {
  736         -
                            Vec::with_capacity(cap)
  737         -
                        } else {
  738         -
                            Vec::new()
  739         -
                        };
  740         -
                        deser.read_list(member, container, |mut list, deser| {
  741         -
                            list.push(crate::types::Compatibility::from(deser.read_string(member)?.as_str()));
  742         -
                            Ok(list)
  743         -
                        })?
         723  +
                        let mut container = Vec::new();
         724  +
                        deser.read_list(member, &mut |deser| {
         725  +
                            container.push(crate::types::Compatibility::from(deser.read_string(member)?.as_str()));
         726  +
                            Ok(())
         727  +
                        })?;
         728  +
                        container
  744    729   
                    });
  745    730   
                }
  746    731   
                Some(12) => {
  747    732   
                    builder.runtime_platform = Some(crate::types::RuntimePlatform::deserialize(deser)?);
  748    733   
                }
  749    734   
                Some(13) => {
  750    735   
                    builder.requires_compatibilities = Some({
  751         -
                        let container = if let Some(cap) = deser.container_size() {
  752         -
                            Vec::with_capacity(cap)
  753         -
                        } else {
  754         -
                            Vec::new()
  755         -
                        };
  756         -
                        deser.read_list(member, container, |mut list, deser| {
  757         -
                            list.push(crate::types::Compatibility::from(deser.read_string(member)?.as_str()));
  758         -
                            Ok(list)
  759         -
                        })?
         736  +
                        let mut container = Vec::new();
         737  +
                        deser.read_list(member, &mut |deser| {
         738  +
                            container.push(crate::types::Compatibility::from(deser.read_string(member)?.as_str()));
         739  +
                            Ok(())
         740  +
                        })?;
         741  +
                        container
  760    742   
                    });
  761    743   
                }
  762    744   
                Some(14) => {
  763    745   
                    builder.cpu = Some(deser.read_string(member)?);
  764    746   
                }
  765    747   
                Some(15) => {
  766    748   
                    builder.memory = Some(deser.read_string(member)?);
  767    749   
                }
  768    750   
                Some(16) => {
  769    751   
                    builder.inference_accelerators = Some({
  770         -
                        let container = if let Some(cap) = deser.container_size() {
  771         -
                            Vec::with_capacity(cap)
  772         -
                        } else {
  773         -
                            Vec::new()
  774         -
                        };
  775         -
                        deser.read_list(member, container, |mut list, deser| {
  776         -
                            list.push(crate::types::InferenceAccelerator::deserialize(deser)?);
  777         -
                            Ok(list)
  778         -
                        })?
         752  +
                        let mut container = Vec::new();
         753  +
                        deser.read_list(member, &mut |deser| {
         754  +
                            container.push(crate::types::InferenceAccelerator::deserialize(deser)?);
         755  +
                            Ok(())
         756  +
                        })?;
         757  +
                        container
  779    758   
                    });
  780    759   
                }
  781    760   
                Some(17) => {
  782    761   
                    builder.pid_mode = Some(crate::types::PidMode::from(deser.read_string(member)?.as_str()));
  783    762   
                }
  784    763   
                Some(18) => {
  785    764   
                    builder.ipc_mode = Some(crate::types::IpcMode::from(deser.read_string(member)?.as_str()));
  786    765   
                }
  787    766   
                Some(19) => {
  788    767   
                    builder.proxy_configuration = Some(crate::types::ProxyConfiguration::deserialize(deser)?);
  789    768   
                }
  790    769   
                Some(20) => {
  791    770   
                    builder.registered_at = Some(deser.read_timestamp(member)?);
  792    771   
                }
  793    772   
                Some(21) => {
  794    773   
                    builder.deregistered_at = Some(deser.read_timestamp(member)?);
  795    774   
                }
  796    775   
                Some(22) => {
  797    776   
                    builder.registered_by = Some(deser.read_string(member)?);
  798    777   
                }
  799    778   
                Some(23) => {
  800    779   
                    builder.ephemeral_storage = Some(crate::types::EphemeralStorage::deserialize(deser)?);
  801    780   
                }
  802    781   
                Some(24) => {
  803    782   
                    builder.enable_fault_injection = Some(deser.read_boolean(member)?);
  804    783   
                }
  805    784   
                _ => {}
  806    785   
            }
  807    786   
            Ok(())
  808    787   
        })?;
  809    788   
        Ok(builder.build())
  810    789   
    }
  811    790   
}
         791  +
impl TaskDefinition {
         792  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         793  +
    pub fn deserialize_with_response(
         794  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         795  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         796  +
        _status: u16,
         797  +
        _body: &[u8],
         798  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         799  +
        Self::deserialize(deserializer)
         800  +
    }
         801  +
}
  812    802   
impl TaskDefinition {
  813    803   
    /// Creates a new builder-style object to manufacture [`TaskDefinition`](crate::types::TaskDefinition).
  814    804   
    pub fn builder() -> crate::types::builders::TaskDefinitionBuilder {
  815    805   
        crate::types::builders::TaskDefinitionBuilder::default()
  816    806   
    }
  817    807   
}
  818    808   
  819    809   
/// A builder for [`TaskDefinition`](crate::types::TaskDefinition).
  820    810   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  821    811   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_definition_placement_constraint.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_ephemeral_storage.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_managed_ebs_volume_configuration.rs

@@ -161,161 +321,321 @@
  181    181   
    "encrypted",
  182    182   
    0,
  183    183   
);
  184    184   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$kmsKeyId",
  187    187   
        "com.amazonaws.ecs",
  188    188   
        "TaskManagedEBSVolumeConfiguration",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::String,
  191         -
    "kms_key_id",
         191  +
    "kmsKeyId",
  192    192   
    1,
  193    193   
);
  194    194   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$volumeType",
  197    197   
        "com.amazonaws.ecs",
  198    198   
        "TaskManagedEBSVolumeConfiguration",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::String,
  201         -
    "volume_type",
         201  +
    "volumeType",
  202    202   
    2,
  203    203   
);
  204    204   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_SIZE_IN_GIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$sizeInGiB",
  207    207   
        "com.amazonaws.ecs",
  208    208   
        "TaskManagedEBSVolumeConfiguration",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::Integer,
  211         -
    "size_in_gib",
         211  +
    "sizeInGiB",
  212    212   
    3,
  213    213   
);
  214    214   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static(
  216    216   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$snapshotId",
  217    217   
        "com.amazonaws.ecs",
  218    218   
        "TaskManagedEBSVolumeConfiguration",
  219    219   
    ),
  220    220   
    ::aws_smithy_schema::ShapeType::String,
  221         -
    "snapshot_id",
         221  +
    "snapshotId",
  222    222   
    4,
  223    223   
);
  224    224   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_VOLUME_INITIALIZATION_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  225    225   
    ::aws_smithy_schema::ShapeId::from_static(
  226    226   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$volumeInitializationRate",
  227    227   
        "com.amazonaws.ecs",
  228    228   
        "TaskManagedEBSVolumeConfiguration",
  229    229   
    ),
  230    230   
    ::aws_smithy_schema::ShapeType::Integer,
  231         -
    "volume_initialization_rate",
         231  +
    "volumeInitializationRate",
  232    232   
    5,
  233    233   
);
  234    234   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  235    235   
    ::aws_smithy_schema::ShapeId::from_static(
  236    236   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$iops",
  237    237   
        "com.amazonaws.ecs",
  238    238   
        "TaskManagedEBSVolumeConfiguration",
  239    239   
    ),
  240    240   
    ::aws_smithy_schema::ShapeType::Integer,
  241    241   
    "iops",
  242    242   
    6,
  243    243   
);
  244    244   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  245    245   
    ::aws_smithy_schema::ShapeId::from_static(
  246    246   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$throughput",
  247    247   
        "com.amazonaws.ecs",
  248    248   
        "TaskManagedEBSVolumeConfiguration",
  249    249   
    ),
  250    250   
    ::aws_smithy_schema::ShapeType::Integer,
  251    251   
    "throughput",
  252    252   
    7,
  253    253   
);
  254    254   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  255    255   
    ::aws_smithy_schema::ShapeId::from_static(
  256    256   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$tagSpecifications",
  257    257   
        "com.amazonaws.ecs",
  258    258   
        "TaskManagedEBSVolumeConfiguration",
  259    259   
    ),
  260    260   
    ::aws_smithy_schema::ShapeType::List,
  261         -
    "tag_specifications",
         261  +
    "tagSpecifications",
  262    262   
    8,
  263    263   
);
  264    264   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  265    265   
    ::aws_smithy_schema::ShapeId::from_static(
  266    266   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$roleArn",
  267    267   
        "com.amazonaws.ecs",
  268    268   
        "TaskManagedEBSVolumeConfiguration",
  269    269   
    ),
  270    270   
    ::aws_smithy_schema::ShapeType::String,
  271         -
    "role_arn",
         271  +
    "roleArn",
  272    272   
    9,
  273    273   
);
  274    274   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_TERMINATION_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  275    275   
    ::aws_smithy_schema::ShapeId::from_static(
  276    276   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$terminationPolicy",
  277    277   
        "com.amazonaws.ecs",
  278    278   
        "TaskManagedEBSVolumeConfiguration",
  279    279   
    ),
  280    280   
    ::aws_smithy_schema::ShapeType::Structure,
  281         -
    "termination_policy",
         281  +
    "terminationPolicy",
  282    282   
    10,
  283    283   
);
  284    284   
static TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_FILESYSTEM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static(
  286    286   
        "com.amazonaws.ecs#TaskManagedEBSVolumeConfiguration$filesystemType",
  287    287   
        "com.amazonaws.ecs",
  288    288   
        "TaskManagedEBSVolumeConfiguration",
  289    289   
    ),
  290    290   
    ::aws_smithy_schema::ShapeType::String,
  291         -
    "filesystem_type",
         291  +
    "filesystemType",
  292    292   
    11,
  293    293   
);
  294    294   
static TASKMANAGEDEBSVOLUMECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  295    295   
    TASKMANAGEDEBSVOLUMECONFIGURATION_SCHEMA_ID,
  296    296   
    ::aws_smithy_schema::ShapeType::Structure,
  297    297   
    &[
  298    298   
        &TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_ENCRYPTED,
  299    299   
        &TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_KMS_KEY_ID,
  300    300   
        &TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_VOLUME_TYPE,
  301    301   
        &TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_SIZE_IN_GIB,
@@ -342,342 +470,479 @@
  362    362   
            ser.write_struct(&TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_TERMINATION_POLICY, val)?;
  363    363   
        }
  364    364   
        if let Some(ref val) = self.filesystem_type {
  365    365   
            ser.write_string(&TASKMANAGEDEBSVOLUMECONFIGURATION_MEMBER_FILESYSTEM_TYPE, val.as_str())?;
  366    366   
        }
  367    367   
        Ok(())
  368    368   
    }
  369    369   
}
  370    370   
impl TaskManagedEbsVolumeConfiguration {
  371    371   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  372         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  373         -
        deserializer: &mut D,
         372  +
    pub fn deserialize(
         373  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  374    374   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  375    375   
        #[allow(unused_variables, unused_mut)]
  376    376   
        let mut builder = Self::builder();
  377    377   
        #[allow(
  378    378   
            unused_variables,
  379    379   
            unreachable_code,
  380    380   
            clippy::single_match,
  381    381   
            clippy::match_single_binding,
  382    382   
            clippy::diverging_sub_expression
  383    383   
        )]
  384         -
        deserializer.read_struct(&TASKMANAGEDEBSVOLUMECONFIGURATION_SCHEMA, (), |_, member, deser| {
         384  +
        deserializer.read_struct(&TASKMANAGEDEBSVOLUMECONFIGURATION_SCHEMA, &mut |member, deser| {
  385    385   
            match member.member_index() {
  386    386   
                Some(0) => {
  387    387   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  388    388   
                }
  389    389   
                Some(1) => {
  390    390   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  391    391   
                }
  392    392   
                Some(2) => {
  393    393   
                    builder.volume_type = Some(deser.read_string(member)?);
  394    394   
                }
  395    395   
                Some(3) => {
  396    396   
                    builder.size_in_gib = Some(deser.read_integer(member)?);
  397    397   
                }
  398    398   
                Some(4) => {
  399    399   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  400    400   
                }
  401    401   
                Some(5) => {
  402    402   
                    builder.volume_initialization_rate = Some(deser.read_integer(member)?);
  403    403   
                }
  404    404   
                Some(6) => {
  405    405   
                    builder.iops = Some(deser.read_integer(member)?);
  406    406   
                }
  407    407   
                Some(7) => {
  408    408   
                    builder.throughput = Some(deser.read_integer(member)?);
  409    409   
                }
  410    410   
                Some(8) => {
  411    411   
                    builder.tag_specifications = Some({
  412         -
                        let container = if let Some(cap) = deser.container_size() {
  413         -
                            Vec::with_capacity(cap)
  414         -
                        } else {
  415         -
                            Vec::new()
  416         -
                        };
  417         -
                        deser.read_list(member, container, |mut list, deser| {
  418         -
                            list.push(crate::types::EbsTagSpecification::deserialize(deser)?);
  419         -
                            Ok(list)
  420         -
                        })?
         412  +
                        let mut container = Vec::new();
         413  +
                        deser.read_list(member, &mut |deser| {
         414  +
                            container.push(crate::types::EbsTagSpecification::deserialize(deser)?);
         415  +
                            Ok(())
         416  +
                        })?;
         417  +
                        container
  421    418   
                    });
  422    419   
                }
  423    420   
                Some(9) => {
  424    421   
                    builder.role_arn = Some(deser.read_string(member)?);
  425    422   
                }
  426    423   
                Some(10) => {
  427    424   
                    builder.termination_policy = Some(crate::types::TaskManagedEbsVolumeTerminationPolicy::deserialize(deser)?);
  428    425   
                }
  429    426   
                Some(11) => {
  430    427   
                    builder.filesystem_type = Some(crate::types::TaskFilesystemType::from(deser.read_string(member)?.as_str()));
  431    428   
                }
  432    429   
                _ => {}
  433    430   
            }
  434    431   
            Ok(())
  435    432   
        })?;
         433  +
        builder.role_arn = builder.role_arn.or(Some(String::new()));
  436    434   
        builder
  437    435   
            .build()
  438    436   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  439    437   
    }
  440    438   
}
         439  +
impl TaskManagedEbsVolumeConfiguration {
         440  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         441  +
    pub fn deserialize_with_response(
         442  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         443  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         444  +
        _status: u16,
         445  +
        _body: &[u8],
         446  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         447  +
        Self::deserialize(deserializer)
         448  +
    }
         449  +
}
  441    450   
impl TaskManagedEbsVolumeConfiguration {
  442    451   
    /// Creates a new builder-style object to manufacture [`TaskManagedEbsVolumeConfiguration`](crate::types::TaskManagedEbsVolumeConfiguration).
  443    452   
    pub fn builder() -> crate::types::builders::TaskManagedEbsVolumeConfigurationBuilder {
  444    453   
        crate::types::builders::TaskManagedEbsVolumeConfigurationBuilder::default()
  445    454   
    }
  446    455   
}
  447    456   
  448    457   
/// A builder for [`TaskManagedEbsVolumeConfiguration`](crate::types::TaskManagedEbsVolumeConfiguration).
  449    458   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  450    459   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_managed_ebs_volume_termination_policy.rs

@@ -1,1 +110,122 @@
   18     18   
    "com.amazonaws.ecs",
   19     19   
    "TaskManagedEBSVolumeTerminationPolicy",
   20     20   
);
   21     21   
static TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_MEMBER_DELETE_ON_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.ecs#TaskManagedEBSVolumeTerminationPolicy$deleteOnTermination",
   24     24   
        "com.amazonaws.ecs",
   25     25   
        "TaskManagedEBSVolumeTerminationPolicy",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Boolean,
   28         -
    "delete_on_termination",
          28  +
    "deleteOnTermination",
   29     29   
    0,
   30     30   
);
   31     31   
static TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_MEMBER_DELETE_ON_TERMINATION],
   35     35   
);
   36     36   
impl TaskManagedEbsVolumeTerminationPolicy {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for TaskManagedEbsVolumeTerminationPolicy {
   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   
        {
   47     47   
            let val = &self.delete_on_termination;
   48     48   
            ser.write_boolean(&TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_MEMBER_DELETE_ON_TERMINATION, *val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl TaskManagedEbsVolumeTerminationPolicy {
   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(&TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&TASKMANAGEDEBSVOLUMETERMINATIONPOLICY_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.delete_on_termination = Some(deser.read_boolean(member)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
          76  +
        builder.delete_on_termination = builder.delete_on_termination.or(Some(false));
   76     77   
        builder
   77     78   
            .build()
   78     79   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   79     80   
    }
   80     81   
}
          82  +
impl TaskManagedEbsVolumeTerminationPolicy {
          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  +
}
   81     93   
impl TaskManagedEbsVolumeTerminationPolicy {
   82     94   
    /// Creates a new builder-style object to manufacture [`TaskManagedEbsVolumeTerminationPolicy`](crate::types::TaskManagedEbsVolumeTerminationPolicy).
   83     95   
    pub fn builder() -> crate::types::builders::TaskManagedEbsVolumeTerminationPolicyBuilder {
   84     96   
        crate::types::builders::TaskManagedEbsVolumeTerminationPolicyBuilder::default()
   85     97   
    }
   86     98   
}
   87     99   
   88    100   
/// A builder for [`TaskManagedEbsVolumeTerminationPolicy`](crate::types::TaskManagedEbsVolumeTerminationPolicy).
   89    101   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   90    102   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_override.rs

@@ -47,47 +147,147 @@
   67     67   
    /// </note>
   68     68   
    pub fn ephemeral_storage(&self) -> ::std::option::Option<&crate::types::EphemeralStorage> {
   69     69   
        self.ephemeral_storage.as_ref()
   70     70   
    }
   71     71   
}
   72     72   
static TASKOVERRIDE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride", "com.amazonaws.ecs", "TaskOverride");
   74     74   
static TASKOVERRIDE_MEMBER_CONTAINER_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride$containerOverrides", "com.amazonaws.ecs", "TaskOverride"),
   76     76   
    ::aws_smithy_schema::ShapeType::List,
   77         -
    "container_overrides",
          77  +
    "containerOverrides",
   78     78   
    0,
   79     79   
);
   80     80   
static TASKOVERRIDE_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride$cpu", "com.amazonaws.ecs", "TaskOverride"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83     83   
    "cpu",
   84     84   
    1,
   85     85   
);
   86     86   
static TASKOVERRIDE_MEMBER_INFERENCE_ACCELERATOR_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.ecs#TaskOverride$inferenceAcceleratorOverrides",
   89     89   
        "com.amazonaws.ecs",
   90     90   
        "TaskOverride",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::List,
   93         -
    "inference_accelerator_overrides",
          93  +
    "inferenceAcceleratorOverrides",
   94     94   
    2,
   95     95   
);
   96     96   
static TASKOVERRIDE_MEMBER_EXECUTION_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride$executionRoleArn", "com.amazonaws.ecs", "TaskOverride"),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "execution_role_arn",
          99  +
    "executionRoleArn",
  100    100   
    3,
  101    101   
);
  102    102   
static TASKOVERRIDE_MEMBER_MEMORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride$memory", "com.amazonaws.ecs", "TaskOverride"),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105    105   
    "memory",
  106    106   
    4,
  107    107   
);
  108    108   
static TASKOVERRIDE_MEMBER_TASK_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride$taskRoleArn", "com.amazonaws.ecs", "TaskOverride"),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "task_role_arn",
         111  +
    "taskRoleArn",
  112    112   
    5,
  113    113   
);
  114    114   
static TASKOVERRIDE_MEMBER_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskOverride$ephemeralStorage", "com.amazonaws.ecs", "TaskOverride"),
  116    116   
    ::aws_smithy_schema::ShapeType::Structure,
  117         -
    "ephemeral_storage",
         117  +
    "ephemeralStorage",
  118    118   
    6,
  119    119   
);
  120    120   
static TASKOVERRIDE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  121    121   
    TASKOVERRIDE_SCHEMA_ID,
  122    122   
    ::aws_smithy_schema::ShapeType::Structure,
  123    123   
    &[
  124    124   
        &TASKOVERRIDE_MEMBER_CONTAINER_OVERRIDES,
  125    125   
        &TASKOVERRIDE_MEMBER_CPU,
  126    126   
        &TASKOVERRIDE_MEMBER_INFERENCE_ACCELERATOR_OVERRIDES,
  127    127   
        &TASKOVERRIDE_MEMBER_EXECUTION_ROLE_ARN,
@@ -155,155 +276,281 @@
  175    175   
            ser.write_string(&TASKOVERRIDE_MEMBER_TASK_ROLE_ARN, val)?;
  176    176   
        }
  177    177   
        if let Some(ref val) = self.ephemeral_storage {
  178    178   
            ser.write_struct(&TASKOVERRIDE_MEMBER_EPHEMERAL_STORAGE, val)?;
  179    179   
        }
  180    180   
        Ok(())
  181    181   
    }
  182    182   
}
  183    183   
impl TaskOverride {
  184    184   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  185         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  186         -
        deserializer: &mut D,
         185  +
    pub fn deserialize(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  187    187   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  188    188   
        #[allow(unused_variables, unused_mut)]
  189    189   
        let mut builder = Self::builder();
  190    190   
        #[allow(
  191    191   
            unused_variables,
  192    192   
            unreachable_code,
  193    193   
            clippy::single_match,
  194    194   
            clippy::match_single_binding,
  195    195   
            clippy::diverging_sub_expression
  196    196   
        )]
  197         -
        deserializer.read_struct(&TASKOVERRIDE_SCHEMA, (), |_, member, deser| {
         197  +
        deserializer.read_struct(&TASKOVERRIDE_SCHEMA, &mut |member, deser| {
  198    198   
            match member.member_index() {
  199    199   
                Some(0) => {
  200    200   
                    builder.container_overrides = Some({
  201         -
                        let container = if let Some(cap) = deser.container_size() {
  202         -
                            Vec::with_capacity(cap)
  203         -
                        } else {
  204         -
                            Vec::new()
  205         -
                        };
  206         -
                        deser.read_list(member, container, |mut list, deser| {
  207         -
                            list.push(crate::types::ContainerOverride::deserialize(deser)?);
  208         -
                            Ok(list)
  209         -
                        })?
         201  +
                        let mut container = Vec::new();
         202  +
                        deser.read_list(member, &mut |deser| {
         203  +
                            container.push(crate::types::ContainerOverride::deserialize(deser)?);
         204  +
                            Ok(())
         205  +
                        })?;
         206  +
                        container
  210    207   
                    });
  211    208   
                }
  212    209   
                Some(1) => {
  213    210   
                    builder.cpu = Some(deser.read_string(member)?);
  214    211   
                }
  215    212   
                Some(2) => {
  216    213   
                    builder.inference_accelerator_overrides = Some({
  217         -
                        let container = if let Some(cap) = deser.container_size() {
  218         -
                            Vec::with_capacity(cap)
  219         -
                        } else {
  220         -
                            Vec::new()
  221         -
                        };
  222         -
                        deser.read_list(member, container, |mut list, deser| {
  223         -
                            list.push(crate::types::InferenceAcceleratorOverride::deserialize(deser)?);
  224         -
                            Ok(list)
  225         -
                        })?
         214  +
                        let mut container = Vec::new();
         215  +
                        deser.read_list(member, &mut |deser| {
         216  +
                            container.push(crate::types::InferenceAcceleratorOverride::deserialize(deser)?);
         217  +
                            Ok(())
         218  +
                        })?;
         219  +
                        container
  226    220   
                    });
  227    221   
                }
  228    222   
                Some(3) => {
  229    223   
                    builder.execution_role_arn = Some(deser.read_string(member)?);
  230    224   
                }
  231    225   
                Some(4) => {
  232    226   
                    builder.memory = Some(deser.read_string(member)?);
  233    227   
                }
  234    228   
                Some(5) => {
  235    229   
                    builder.task_role_arn = Some(deser.read_string(member)?);
  236    230   
                }
  237    231   
                Some(6) => {
  238    232   
                    builder.ephemeral_storage = Some(crate::types::EphemeralStorage::deserialize(deser)?);
  239    233   
                }
  240    234   
                _ => {}
  241    235   
            }
  242    236   
            Ok(())
  243    237   
        })?;
  244    238   
        Ok(builder.build())
  245    239   
    }
  246    240   
}
         241  +
impl TaskOverride {
         242  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         243  +
    pub fn deserialize_with_response(
         244  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         245  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         246  +
        _status: u16,
         247  +
        _body: &[u8],
         248  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         249  +
        Self::deserialize(deserializer)
         250  +
    }
         251  +
}
  247    252   
impl TaskOverride {
  248    253   
    /// Creates a new builder-style object to manufacture [`TaskOverride`](crate::types::TaskOverride).
  249    254   
    pub fn builder() -> crate::types::builders::TaskOverrideBuilder {
  250    255   
        crate::types::builders::TaskOverrideBuilder::default()
  251    256   
    }
  252    257   
}
  253    258   
  254    259   
/// A builder for [`TaskOverride`](crate::types::TaskOverride).
  255    260   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  256    261   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_set.rs

@@ -251,251 +449,449 @@
  271    271   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet", "com.amazonaws.ecs", "TaskSet");
  272    272   
static TASKSET_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  273    273   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$id", "com.amazonaws.ecs", "TaskSet"),
  274    274   
    ::aws_smithy_schema::ShapeType::String,
  275    275   
    "id",
  276    276   
    0,
  277    277   
);
  278    278   
static TASKSET_MEMBER_TASK_SET_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  279    279   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$taskSetArn", "com.amazonaws.ecs", "TaskSet"),
  280    280   
    ::aws_smithy_schema::ShapeType::String,
  281         -
    "task_set_arn",
         281  +
    "taskSetArn",
  282    282   
    1,
  283    283   
);
  284    284   
static TASKSET_MEMBER_SERVICE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$serviceArn", "com.amazonaws.ecs", "TaskSet"),
  286    286   
    ::aws_smithy_schema::ShapeType::String,
  287         -
    "service_arn",
         287  +
    "serviceArn",
  288    288   
    2,
  289    289   
);
  290    290   
static TASKSET_MEMBER_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  291    291   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$clusterArn", "com.amazonaws.ecs", "TaskSet"),
  292    292   
    ::aws_smithy_schema::ShapeType::String,
  293         -
    "cluster_arn",
         293  +
    "clusterArn",
  294    294   
    3,
  295    295   
);
  296    296   
static TASKSET_MEMBER_STARTED_BY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  297    297   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$startedBy", "com.amazonaws.ecs", "TaskSet"),
  298    298   
    ::aws_smithy_schema::ShapeType::String,
  299         -
    "started_by",
         299  +
    "startedBy",
  300    300   
    4,
  301    301   
);
  302    302   
static TASKSET_MEMBER_EXTERNAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  303    303   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$externalId", "com.amazonaws.ecs", "TaskSet"),
  304    304   
    ::aws_smithy_schema::ShapeType::String,
  305         -
    "external_id",
         305  +
    "externalId",
  306    306   
    5,
  307    307   
);
  308    308   
static TASKSET_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  309    309   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$status", "com.amazonaws.ecs", "TaskSet"),
  310    310   
    ::aws_smithy_schema::ShapeType::String,
  311    311   
    "status",
  312    312   
    6,
  313    313   
);
  314    314   
static TASKSET_MEMBER_TASK_DEFINITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  315    315   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$taskDefinition", "com.amazonaws.ecs", "TaskSet"),
  316    316   
    ::aws_smithy_schema::ShapeType::String,
  317         -
    "task_definition",
         317  +
    "taskDefinition",
  318    318   
    7,
  319    319   
);
  320    320   
static TASKSET_MEMBER_COMPUTED_DESIRED_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  321    321   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$computedDesiredCount", "com.amazonaws.ecs", "TaskSet"),
  322    322   
    ::aws_smithy_schema::ShapeType::Integer,
  323         -
    "computed_desired_count",
         323  +
    "computedDesiredCount",
  324    324   
    8,
  325    325   
);
  326    326   
static TASKSET_MEMBER_PENDING_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  327    327   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$pendingCount", "com.amazonaws.ecs", "TaskSet"),
  328    328   
    ::aws_smithy_schema::ShapeType::Integer,
  329         -
    "pending_count",
         329  +
    "pendingCount",
  330    330   
    9,
  331    331   
);
  332    332   
static TASKSET_MEMBER_RUNNING_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  333    333   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$runningCount", "com.amazonaws.ecs", "TaskSet"),
  334    334   
    ::aws_smithy_schema::ShapeType::Integer,
  335         -
    "running_count",
         335  +
    "runningCount",
  336    336   
    10,
  337    337   
);
  338    338   
static TASKSET_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  339    339   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$createdAt", "com.amazonaws.ecs", "TaskSet"),
  340    340   
    ::aws_smithy_schema::ShapeType::Timestamp,
  341         -
    "created_at",
         341  +
    "createdAt",
  342    342   
    11,
  343    343   
);
  344    344   
static TASKSET_MEMBER_UPDATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  345    345   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$updatedAt", "com.amazonaws.ecs", "TaskSet"),
  346    346   
    ::aws_smithy_schema::ShapeType::Timestamp,
  347         -
    "updated_at",
         347  +
    "updatedAt",
  348    348   
    12,
  349    349   
);
  350    350   
static TASKSET_MEMBER_LAUNCH_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  351    351   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$launchType", "com.amazonaws.ecs", "TaskSet"),
  352    352   
    ::aws_smithy_schema::ShapeType::String,
  353         -
    "launch_type",
         353  +
    "launchType",
  354    354   
    13,
  355    355   
);
  356    356   
static TASKSET_MEMBER_CAPACITY_PROVIDER_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  357    357   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$capacityProviderStrategy", "com.amazonaws.ecs", "TaskSet"),
  358    358   
    ::aws_smithy_schema::ShapeType::List,
  359         -
    "capacity_provider_strategy",
         359  +
    "capacityProviderStrategy",
  360    360   
    14,
  361    361   
);
  362    362   
static TASKSET_MEMBER_PLATFORM_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  363    363   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$platformVersion", "com.amazonaws.ecs", "TaskSet"),
  364    364   
    ::aws_smithy_schema::ShapeType::String,
  365         -
    "platform_version",
         365  +
    "platformVersion",
  366    366   
    15,
  367    367   
);
  368    368   
static TASKSET_MEMBER_PLATFORM_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  369    369   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$platformFamily", "com.amazonaws.ecs", "TaskSet"),
  370    370   
    ::aws_smithy_schema::ShapeType::String,
  371         -
    "platform_family",
         371  +
    "platformFamily",
  372    372   
    16,
  373    373   
);
  374    374   
static TASKSET_MEMBER_NETWORK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  375    375   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$networkConfiguration", "com.amazonaws.ecs", "TaskSet"),
  376    376   
    ::aws_smithy_schema::ShapeType::Structure,
  377         -
    "network_configuration",
         377  +
    "networkConfiguration",
  378    378   
    17,
  379    379   
);
  380    380   
static TASKSET_MEMBER_LOAD_BALANCERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  381    381   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$loadBalancers", "com.amazonaws.ecs", "TaskSet"),
  382    382   
    ::aws_smithy_schema::ShapeType::List,
  383         -
    "load_balancers",
         383  +
    "loadBalancers",
  384    384   
    18,
  385    385   
);
  386    386   
static TASKSET_MEMBER_SERVICE_REGISTRIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  387    387   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$serviceRegistries", "com.amazonaws.ecs", "TaskSet"),
  388    388   
    ::aws_smithy_schema::ShapeType::List,
  389         -
    "service_registries",
         389  +
    "serviceRegistries",
  390    390   
    19,
  391    391   
);
  392    392   
static TASKSET_MEMBER_SCALE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  393    393   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$scale", "com.amazonaws.ecs", "TaskSet"),
  394    394   
    ::aws_smithy_schema::ShapeType::Structure,
  395    395   
    "scale",
  396    396   
    20,
  397    397   
);
  398    398   
static TASKSET_MEMBER_STABILITY_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  399    399   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$stabilityStatus", "com.amazonaws.ecs", "TaskSet"),
  400    400   
    ::aws_smithy_schema::ShapeType::String,
  401         -
    "stability_status",
         401  +
    "stabilityStatus",
  402    402   
    21,
  403    403   
);
  404    404   
static TASKSET_MEMBER_STABILITY_STATUS_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  405    405   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$stabilityStatusAt", "com.amazonaws.ecs", "TaskSet"),
  406    406   
    ::aws_smithy_schema::ShapeType::Timestamp,
  407         -
    "stability_status_at",
         407  +
    "stabilityStatusAt",
  408    408   
    22,
  409    409   
);
  410    410   
static TASKSET_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  411    411   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$tags", "com.amazonaws.ecs", "TaskSet"),
  412    412   
    ::aws_smithy_schema::ShapeType::List,
  413    413   
    "tags",
  414    414   
    23,
  415    415   
);
  416    416   
static TASKSET_MEMBER_FARGATE_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  417    417   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TaskSet$fargateEphemeralStorage", "com.amazonaws.ecs", "TaskSet"),
  418    418   
    ::aws_smithy_schema::ShapeType::Structure,
  419         -
    "fargate_ephemeral_storage",
         419  +
    "fargateEphemeralStorage",
  420    420   
    24,
  421    421   
);
  422    422   
static TASKSET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  423    423   
    TASKSET_SCHEMA_ID,
  424    424   
    ::aws_smithy_schema::ShapeType::Structure,
  425    425   
    &[
  426    426   
        &TASKSET_MEMBER_ID,
  427    427   
        &TASKSET_MEMBER_TASK_SET_ARN,
  428    428   
        &TASKSET_MEMBER_SERVICE_ARN,
  429    429   
        &TASKSET_MEMBER_CLUSTER_ARN,
@@ -545,545 +740,739 @@
  565    565   
            })?;
  566    566   
        }
  567    567   
        if let Some(ref val) = self.fargate_ephemeral_storage {
  568    568   
            ser.write_struct(&TASKSET_MEMBER_FARGATE_EPHEMERAL_STORAGE, val)?;
  569    569   
        }
  570    570   
        Ok(())
  571    571   
    }
  572    572   
}
  573    573   
impl TaskSet {
  574    574   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  575         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  576         -
        deserializer: &mut D,
         575  +
    pub fn deserialize(
         576  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  577    577   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  578    578   
        #[allow(unused_variables, unused_mut)]
  579    579   
        let mut builder = Self::builder();
  580    580   
        #[allow(
  581    581   
            unused_variables,
  582    582   
            unreachable_code,
  583    583   
            clippy::single_match,
  584    584   
            clippy::match_single_binding,
  585    585   
            clippy::diverging_sub_expression
  586    586   
        )]
  587         -
        deserializer.read_struct(&TASKSET_SCHEMA, (), |_, member, deser| {
         587  +
        deserializer.read_struct(&TASKSET_SCHEMA, &mut |member, deser| {
  588    588   
            match member.member_index() {
  589    589   
                Some(0) => {
  590    590   
                    builder.id = Some(deser.read_string(member)?);
  591    591   
                }
  592    592   
                Some(1) => {
  593    593   
                    builder.task_set_arn = Some(deser.read_string(member)?);
  594    594   
                }
  595    595   
                Some(2) => {
  596    596   
                    builder.service_arn = Some(deser.read_string(member)?);
  597    597   
                }
  598    598   
                Some(3) => {
  599    599   
                    builder.cluster_arn = Some(deser.read_string(member)?);
  600    600   
                }
  601    601   
                Some(4) => {
  602    602   
                    builder.started_by = Some(deser.read_string(member)?);
  603    603   
                }
  604    604   
                Some(5) => {
  605    605   
                    builder.external_id = Some(deser.read_string(member)?);
  606    606   
                }
  607    607   
                Some(6) => {
  608    608   
                    builder.status = Some(deser.read_string(member)?);
  609    609   
                }
  610    610   
                Some(7) => {
  611    611   
                    builder.task_definition = Some(deser.read_string(member)?);
  612    612   
                }
  613    613   
                Some(8) => {
  614    614   
                    builder.computed_desired_count = Some(deser.read_integer(member)?);
  615    615   
                }
  616    616   
                Some(9) => {
  617    617   
                    builder.pending_count = Some(deser.read_integer(member)?);
  618    618   
                }
  619    619   
                Some(10) => {
  620    620   
                    builder.running_count = Some(deser.read_integer(member)?);
  621    621   
                }
  622    622   
                Some(11) => {
  623    623   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  624    624   
                }
  625    625   
                Some(12) => {
  626    626   
                    builder.updated_at = Some(deser.read_timestamp(member)?);
  627    627   
                }
  628    628   
                Some(13) => {
  629    629   
                    builder.launch_type = Some(crate::types::LaunchType::from(deser.read_string(member)?.as_str()));
  630    630   
                }
  631    631   
                Some(14) => {
  632    632   
                    builder.capacity_provider_strategy = Some({
  633         -
                        let container = if let Some(cap) = deser.container_size() {
  634         -
                            Vec::with_capacity(cap)
  635         -
                        } else {
  636         -
                            Vec::new()
  637         -
                        };
  638         -
                        deser.read_list(member, container, |mut list, deser| {
  639         -
                            list.push(crate::types::CapacityProviderStrategyItem::deserialize(deser)?);
  640         -
                            Ok(list)
  641         -
                        })?
         633  +
                        let mut container = Vec::new();
         634  +
                        deser.read_list(member, &mut |deser| {
         635  +
                            container.push(crate::types::CapacityProviderStrategyItem::deserialize(deser)?);
         636  +
                            Ok(())
         637  +
                        })?;
         638  +
                        container
  642    639   
                    });
  643    640   
                }
  644    641   
                Some(15) => {
  645    642   
                    builder.platform_version = Some(deser.read_string(member)?);
  646    643   
                }
  647    644   
                Some(16) => {
  648    645   
                    builder.platform_family = Some(deser.read_string(member)?);
  649    646   
                }
  650    647   
                Some(17) => {
  651    648   
                    builder.network_configuration = Some(crate::types::NetworkConfiguration::deserialize(deser)?);
  652    649   
                }
  653    650   
                Some(18) => {
  654    651   
                    builder.load_balancers = Some({
  655         -
                        let container = if let Some(cap) = deser.container_size() {
  656         -
                            Vec::with_capacity(cap)
  657         -
                        } else {
  658         -
                            Vec::new()
  659         -
                        };
  660         -
                        deser.read_list(member, container, |mut list, deser| {
  661         -
                            list.push(crate::types::LoadBalancer::deserialize(deser)?);
  662         -
                            Ok(list)
  663         -
                        })?
         652  +
                        let mut container = Vec::new();
         653  +
                        deser.read_list(member, &mut |deser| {
         654  +
                            container.push(crate::types::LoadBalancer::deserialize(deser)?);
         655  +
                            Ok(())
         656  +
                        })?;
         657  +
                        container
  664    658   
                    });
  665    659   
                }
  666    660   
                Some(19) => {
  667    661   
                    builder.service_registries = Some({
  668         -
                        let container = if let Some(cap) = deser.container_size() {
  669         -
                            Vec::with_capacity(cap)
  670         -
                        } else {
  671         -
                            Vec::new()
  672         -
                        };
  673         -
                        deser.read_list(member, container, |mut list, deser| {
  674         -
                            list.push(crate::types::ServiceRegistry::deserialize(deser)?);
  675         -
                            Ok(list)
  676         -
                        })?
         662  +
                        let mut container = Vec::new();
         663  +
                        deser.read_list(member, &mut |deser| {
         664  +
                            container.push(crate::types::ServiceRegistry::deserialize(deser)?);
         665  +
                            Ok(())
         666  +
                        })?;
         667  +
                        container
  677    668   
                    });
  678    669   
                }
  679    670   
                Some(20) => {
  680    671   
                    builder.scale = Some(crate::types::Scale::deserialize(deser)?);
  681    672   
                }
  682    673   
                Some(21) => {
  683    674   
                    builder.stability_status = Some(crate::types::StabilityStatus::from(deser.read_string(member)?.as_str()));
  684    675   
                }
  685    676   
                Some(22) => {
  686    677   
                    builder.stability_status_at = Some(deser.read_timestamp(member)?);
  687    678   
                }
  688    679   
                Some(23) => {
  689    680   
                    builder.tags = Some({
  690         -
                        let container = if let Some(cap) = deser.container_size() {
  691         -
                            Vec::with_capacity(cap)
  692         -
                        } else {
  693         -
                            Vec::new()
  694         -
                        };
  695         -
                        deser.read_list(member, container, |mut list, deser| {
  696         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  697         -
                            Ok(list)
  698         -
                        })?
         681  +
                        let mut container = Vec::new();
         682  +
                        deser.read_list(member, &mut |deser| {
         683  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         684  +
                            Ok(())
         685  +
                        })?;
         686  +
                        container
  699    687   
                    });
  700    688   
                }
  701    689   
                Some(24) => {
  702    690   
                    builder.fargate_ephemeral_storage = Some(crate::types::DeploymentEphemeralStorage::deserialize(deser)?);
  703    691   
                }
  704    692   
                _ => {}
  705    693   
            }
  706    694   
            Ok(())
  707    695   
        })?;
  708    696   
        Ok(builder.build())
  709    697   
    }
  710    698   
}
         699  +
impl TaskSet {
         700  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         701  +
    pub fn deserialize_with_response(
         702  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         703  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         704  +
        _status: u16,
         705  +
        _body: &[u8],
         706  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         707  +
        Self::deserialize(deserializer)
         708  +
    }
         709  +
}
  711    710   
impl TaskSet {
  712    711   
    /// Creates a new builder-style object to manufacture [`TaskSet`](crate::types::TaskSet).
  713    712   
    pub fn builder() -> crate::types::builders::TaskSetBuilder {
  714    713   
        crate::types::builders::TaskSetBuilder::default()
  715    714   
    }
  716    715   
}
  717    716   
  718    717   
/// A builder for [`TaskSet`](crate::types::TaskSet).
  719    718   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  720    719   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_task_volume_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_timeout_configuration.rs

@@ -7,7 +135,146 @@
   27     27   
}
   28     28   
static TIMEOUTCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#TimeoutConfiguration", "com.amazonaws.ecs", "TimeoutConfiguration");
   30     30   
static TIMEOUTCONFIGURATION_MEMBER_IDLE_TIMEOUT_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.ecs#TimeoutConfiguration$idleTimeoutSeconds",
   33     33   
        "com.amazonaws.ecs",
   34     34   
        "TimeoutConfiguration",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::Integer,
   37         -
    "idle_timeout_seconds",
          37  +
    "idleTimeoutSeconds",
   38     38   
    0,
   39     39   
);
   40     40   
static TIMEOUTCONFIGURATION_MEMBER_PER_REQUEST_TIMEOUT_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ecs#TimeoutConfiguration$perRequestTimeoutSeconds",
   43     43   
        "com.amazonaws.ecs",
   44     44   
        "TimeoutConfiguration",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::Integer,
   47         -
    "per_request_timeout_seconds",
          47  +
    "perRequestTimeoutSeconds",
   48     48   
    1,
   49     49   
);
   50     50   
static TIMEOUTCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   51     51   
    TIMEOUTCONFIGURATION_SCHEMA_ID,
   52     52   
    ::aws_smithy_schema::ShapeType::Structure,
   53     53   
    &[
   54     54   
        &TIMEOUTCONFIGURATION_MEMBER_IDLE_TIMEOUT_SECONDS,
   55     55   
        &TIMEOUTCONFIGURATION_MEMBER_PER_REQUEST_TIMEOUT_SECONDS,
   56     56   
    ],
   57     57   
);
   58     58   
impl TimeoutConfiguration {
   59     59   
    /// The schema for this shape.
   60     60   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TIMEOUTCONFIGURATION_SCHEMA;
   61     61   
}
   62     62   
impl ::aws_smithy_schema::serde::SerializableStruct for TimeoutConfiguration {
   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.idle_timeout_seconds {
   69     69   
            ser.write_integer(&TIMEOUTCONFIGURATION_MEMBER_IDLE_TIMEOUT_SECONDS, *val)?;
   70     70   
        }
   71     71   
        if let Some(ref val) = self.per_request_timeout_seconds {
   72     72   
            ser.write_integer(&TIMEOUTCONFIGURATION_MEMBER_PER_REQUEST_TIMEOUT_SECONDS, *val)?;
   73     73   
        }
   74     74   
        Ok(())
   75     75   
    }
   76     76   
}
   77     77   
impl TimeoutConfiguration {
   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(&TIMEOUTCONFIGURATION_SCHEMA, (), |_, member, deser| {
          91  +
        deserializer.read_struct(&TIMEOUTCONFIGURATION_SCHEMA, &mut |member, deser| {
   92     92   
            match member.member_index() {
   93     93   
                Some(0) => {
   94     94   
                    builder.idle_timeout_seconds = Some(deser.read_integer(member)?);
   95     95   
                }
   96     96   
                Some(1) => {
   97     97   
                    builder.per_request_timeout_seconds = Some(deser.read_integer(member)?);
   98     98   
                }
   99     99   
                _ => {}
  100    100   
            }
  101    101   
            Ok(())
  102    102   
        })?;
  103    103   
        Ok(builder.build())
  104    104   
    }
  105    105   
}
         106  +
impl TimeoutConfiguration {
         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 TimeoutConfiguration {
  107    118   
    /// Creates a new builder-style object to manufacture [`TimeoutConfiguration`](crate::types::TimeoutConfiguration).
  108    119   
    pub fn builder() -> crate::types::builders::TimeoutConfigurationBuilder {
  109    120   
        crate::types::builders::TimeoutConfigurationBuilder::default()
  110    121   
    }
  111    122   
}
  112    123   
  113    124   
/// A builder for [`TimeoutConfiguration`](crate::types::TimeoutConfiguration).
  114    125   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  115    126   
#[non_exhaustive]