AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

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

@@ -47,47 +136,147 @@
   67     67   
            ser.write_string(&FAILURE_MEMBER_REASON, val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.detail {
   70     70   
            ser.write_string(&FAILURE_MEMBER_DETAIL, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl Failure {
   76     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     79   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        #[allow(unused_variables, unused_mut)]
   81     81   
        let mut builder = Self::builder();
   82     82   
        #[allow(
   83     83   
            unused_variables,
   84     84   
            unreachable_code,
   85     85   
            clippy::single_match,
   86     86   
            clippy::match_single_binding,
   87     87   
            clippy::diverging_sub_expression
   88     88   
        )]
   89         -
        deserializer.read_struct(&FAILURE_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&FAILURE_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.arn = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.reason = Some(deser.read_string(member)?);
   96     96   
                }
   97     97   
                Some(2) => {
   98     98   
                    builder.detail = 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 Failure {
         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 Failure {
  108    119   
    /// Creates a new builder-style object to manufacture [`Failure`](crate::types::Failure).
  109    120   
    pub fn builder() -> crate::types::builders::FailureBuilder {
  110    121   
        crate::types::builders::FailureBuilder::default()
  111    122   
    }
  112    123   
}
  113    124   
  114    125   
/// A builder for [`Failure`](crate::types::Failure).
  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/_firelens_configuration.rs

@@ -5,5 +152,153 @@
   25     25   
}
   26     26   
static FIRELENSCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#FirelensConfiguration", "com.amazonaws.ecs", "FirelensConfiguration");
   28     28   
static FIRELENSCONFIGURATION_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   29     29   
    ::aws_smithy_schema::ShapeId::from_static(
   30     30   
        "com.amazonaws.ecs#FirelensConfiguration$type",
   31     31   
        "com.amazonaws.ecs",
   32     32   
        "FirelensConfiguration",
   33     33   
    ),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "r##type",
          35  +
    "type",
   36     36   
    0,
   37     37   
);
   38     38   
static FIRELENSCONFIGURATION_MEMBER_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.ecs#FirelensConfiguration$options",
   41     41   
        "com.amazonaws.ecs",
   42     42   
        "FirelensConfiguration",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::Map,
   45     45   
    "options",
   46     46   
    1,
   47     47   
);
   48     48   
static FIRELENSCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    FIRELENSCONFIGURATION_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&FIRELENSCONFIGURATION_MEMBER_TYPE, &FIRELENSCONFIGURATION_MEMBER_OPTIONS],
   52     52   
);
   53     53   
impl FirelensConfiguration {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FIRELENSCONFIGURATION_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for FirelensConfiguration {
   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.r#type;
   65     65   
            ser.write_string(&FIRELENSCONFIGURATION_MEMBER_TYPE, val.as_str())?;
   66     66   
        }
   67     67   
        if let Some(ref val) = self.options {
   68     68   
            ser.write_map(
   69     69   
                &FIRELENSCONFIGURATION_MEMBER_OPTIONS,
   70     70   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   71     71   
                    for (key, value) in val {
   72     72   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   73     73   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
   74     74   
                    }
   75     75   
                    Ok(())
   76     76   
                },
   77     77   
            )?;
   78     78   
        }
   79     79   
        Ok(())
   80     80   
    }
   81     81   
}
   82     82   
impl FirelensConfiguration {
   83     83   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   84         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   85         -
        deserializer: &mut D,
          84  +
    pub fn deserialize(
          85  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   86     86   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   87     87   
        #[allow(unused_variables, unused_mut)]
   88     88   
        let mut builder = Self::builder();
   89     89   
        #[allow(
   90     90   
            unused_variables,
   91     91   
            unreachable_code,
   92     92   
            clippy::single_match,
   93     93   
            clippy::match_single_binding,
   94     94   
            clippy::diverging_sub_expression
   95     95   
        )]
   96         -
        deserializer.read_struct(&FIRELENSCONFIGURATION_SCHEMA, (), |_, member, deser| {
          96  +
        deserializer.read_struct(&FIRELENSCONFIGURATION_SCHEMA, &mut |member, deser| {
   97     97   
            match member.member_index() {
   98     98   
                Some(0) => {
   99     99   
                    builder.r#type = Some(crate::types::FirelensConfigurationType::from(deser.read_string(member)?.as_str()));
  100    100   
                }
  101    101   
                Some(1) => {
  102         -
                    builder.options = Some({
  103         -
                        let container = if let Some(cap) = deser.container_size() {
  104         -
                            std::collections::HashMap::with_capacity(cap)
  105         -
                        } else {
  106         -
                            std::collections::HashMap::new()
  107         -
                        };
  108         -
                        deser.read_map(member, container, |mut map, key, deser| {
  109         -
                            map.insert(key, deser.read_string(member)?);
  110         -
                            Ok(map)
  111         -
                        })?
  112         -
                    });
         102  +
                    builder.options = Some(deser.read_string_string_map(member)?);
  113    103   
                }
  114    104   
                _ => {}
  115    105   
            }
  116    106   
            Ok(())
  117    107   
        })?;
  118    108   
        builder
  119    109   
            .build()
  120    110   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  121    111   
    }
  122    112   
}
         113  +
impl FirelensConfiguration {
         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  +
}
  123    124   
impl FirelensConfiguration {
  124    125   
    /// Creates a new builder-style object to manufacture [`FirelensConfiguration`](crate::types::FirelensConfiguration).
  125    126   
    pub fn builder() -> crate::types::builders::FirelensConfigurationBuilder {
  126    127   
        crate::types::builders::FirelensConfigurationBuilder::default()
  127    128   
    }
  128    129   
}
  129    130   
  130    131   
/// A builder for [`FirelensConfiguration`](crate::types::FirelensConfiguration).
  131    132   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  132    133   
#[non_exhaustive]

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

@@ -146,146 +307,309 @@
  166    166   
);
  167    167   
static HEALTHCHECK_MEMBER_RETRIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#HealthCheck$retries", "com.amazonaws.ecs", "HealthCheck"),
  169    169   
    ::aws_smithy_schema::ShapeType::Integer,
  170    170   
    "retries",
  171    171   
    3,
  172    172   
);
  173    173   
static HEALTHCHECK_MEMBER_START_PERIOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#HealthCheck$startPeriod", "com.amazonaws.ecs", "HealthCheck"),
  175    175   
    ::aws_smithy_schema::ShapeType::Integer,
  176         -
    "start_period",
         176  +
    "startPeriod",
  177    177   
    4,
  178    178   
);
  179    179   
static HEALTHCHECK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  180    180   
    HEALTHCHECK_SCHEMA_ID,
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182    182   
    &[
  183    183   
        &HEALTHCHECK_MEMBER_COMMAND,
  184    184   
        &HEALTHCHECK_MEMBER_INTERVAL,
  185    185   
        &HEALTHCHECK_MEMBER_TIMEOUT,
  186    186   
        &HEALTHCHECK_MEMBER_RETRIES,
  187    187   
        &HEALTHCHECK_MEMBER_START_PERIOD,
  188    188   
    ],
  189    189   
);
  190    190   
impl HealthCheck {
  191    191   
    /// The schema for this shape.
  192    192   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HEALTHCHECK_SCHEMA;
  193    193   
}
  194    194   
impl ::aws_smithy_schema::serde::SerializableStruct for HealthCheck {
  195    195   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  196    196   
    fn serialize_members(
  197    197   
        &self,
  198    198   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  199    199   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  200    200   
        {
  201    201   
            let val = &self.command;
  202    202   
  203    203   
            ser.write_list(
  204    204   
                &HEALTHCHECK_MEMBER_COMMAND,
  205    205   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  206    206   
                    for item in val {
  207    207   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  208    208   
                    }
  209    209   
                    Ok(())
  210    210   
                },
  211    211   
            )?;
  212    212   
        }
  213    213   
        if let Some(ref val) = self.interval {
  214    214   
            ser.write_integer(&HEALTHCHECK_MEMBER_INTERVAL, *val)?;
  215    215   
        }
  216    216   
        if let Some(ref val) = self.timeout {
  217    217   
            ser.write_integer(&HEALTHCHECK_MEMBER_TIMEOUT, *val)?;
  218    218   
        }
  219    219   
        if let Some(ref val) = self.retries {
  220    220   
            ser.write_integer(&HEALTHCHECK_MEMBER_RETRIES, *val)?;
  221    221   
        }
  222    222   
        if let Some(ref val) = self.start_period {
  223    223   
            ser.write_integer(&HEALTHCHECK_MEMBER_START_PERIOD, *val)?;
  224    224   
        }
  225    225   
        Ok(())
  226    226   
    }
  227    227   
}
  228    228   
impl HealthCheck {
  229    229   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  230         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  231         -
        deserializer: &mut D,
         230  +
    pub fn deserialize(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  232    232   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  233    233   
        #[allow(unused_variables, unused_mut)]
  234    234   
        let mut builder = Self::builder();
  235    235   
        #[allow(
  236    236   
            unused_variables,
  237    237   
            unreachable_code,
  238    238   
            clippy::single_match,
  239    239   
            clippy::match_single_binding,
  240    240   
            clippy::diverging_sub_expression
  241    241   
        )]
  242         -
        deserializer.read_struct(&HEALTHCHECK_SCHEMA, (), |_, member, deser| {
         242  +
        deserializer.read_struct(&HEALTHCHECK_SCHEMA, &mut |member, deser| {
  243    243   
            match member.member_index() {
  244    244   
                Some(0) => {
  245         -
                    builder.command = Some({
  246         -
                        let container = if let Some(cap) = deser.container_size() {
  247         -
                            Vec::with_capacity(cap)
  248         -
                        } else {
  249         -
                            Vec::new()
  250         -
                        };
  251         -
                        deser.read_list(member, container, |mut list, deser| {
  252         -
                            list.push(deser.read_string(member)?);
  253         -
                            Ok(list)
  254         -
                        })?
  255         -
                    });
         245  +
                    builder.command = Some(deser.read_string_list(member)?);
  256    246   
                }
  257    247   
                Some(1) => {
  258    248   
                    builder.interval = Some(deser.read_integer(member)?);
  259    249   
                }
  260    250   
                Some(2) => {
  261    251   
                    builder.timeout = Some(deser.read_integer(member)?);
  262    252   
                }
  263    253   
                Some(3) => {
  264    254   
                    builder.retries = Some(deser.read_integer(member)?);
  265    255   
                }
  266    256   
                Some(4) => {
  267    257   
                    builder.start_period = Some(deser.read_integer(member)?);
  268    258   
                }
  269    259   
                _ => {}
  270    260   
            }
  271    261   
            Ok(())
  272    262   
        })?;
         263  +
        builder.command = builder.command.or(Some(Vec::new()));
  273    264   
        builder
  274    265   
            .build()
  275    266   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  276    267   
    }
  277    268   
}
         269  +
impl HealthCheck {
         270  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         271  +
    pub fn deserialize_with_response(
         272  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         273  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         274  +
        _status: u16,
         275  +
        _body: &[u8],
         276  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         277  +
        Self::deserialize(deserializer)
         278  +
    }
         279  +
}
  278    280   
impl HealthCheck {
  279    281   
    /// Creates a new builder-style object to manufacture [`HealthCheck`](crate::types::HealthCheck).
  280    282   
    pub fn builder() -> crate::types::builders::HealthCheckBuilder {
  281    283   
        crate::types::builders::HealthCheckBuilder::default()
  282    284   
    }
  283    285   
}
  284    286   
  285    287   
/// A builder for [`HealthCheck`](crate::types::HealthCheck).
  286    288   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  287    289   
#[non_exhaustive]

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

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

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

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

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

@@ -3,3 +132,145 @@
   23     23   
}
   24     24   
static INFERENCEACCELERATOR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#InferenceAccelerator", "com.amazonaws.ecs", "InferenceAccelerator");
   26     26   
static INFERENCEACCELERATOR_MEMBER_DEVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "com.amazonaws.ecs#InferenceAccelerator$deviceName",
   29     29   
        "com.amazonaws.ecs",
   30     30   
        "InferenceAccelerator",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "device_name",
          33  +
    "deviceName",
   34     34   
    0,
   35     35   
);
   36     36   
static INFERENCEACCELERATOR_MEMBER_DEVICE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.ecs#InferenceAccelerator$deviceType",
   39     39   
        "com.amazonaws.ecs",
   40     40   
        "InferenceAccelerator",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::String,
   43         -
    "device_type",
          43  +
    "deviceType",
   44     44   
    1,
   45     45   
);
   46     46   
static INFERENCEACCELERATOR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   47     47   
    INFERENCEACCELERATOR_SCHEMA_ID,
   48     48   
    ::aws_smithy_schema::ShapeType::Structure,
   49     49   
    &[&INFERENCEACCELERATOR_MEMBER_DEVICE_NAME, &INFERENCEACCELERATOR_MEMBER_DEVICE_TYPE],
   50     50   
);
   51     51   
impl InferenceAccelerator {
   52     52   
    /// The schema for this shape.
   53     53   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INFERENCEACCELERATOR_SCHEMA;
   54     54   
}
   55     55   
impl ::aws_smithy_schema::serde::SerializableStruct for InferenceAccelerator {
   56     56   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   57     57   
    fn serialize_members(
   58     58   
        &self,
   59     59   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   60     60   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   61     61   
        {
   62     62   
            let val = &self.device_name;
   63     63   
            ser.write_string(&INFERENCEACCELERATOR_MEMBER_DEVICE_NAME, val)?;
   64     64   
        }
   65     65   
        {
   66     66   
            let val = &self.device_type;
   67     67   
            ser.write_string(&INFERENCEACCELERATOR_MEMBER_DEVICE_TYPE, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl InferenceAccelerator {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&INFERENCEACCELERATOR_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&INFERENCEACCELERATOR_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.device_name = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.device_type = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
          98  +
        builder.device_name = builder.device_name.or(Some(String::new()));
          99  +
        builder.device_type = builder.device_type.or(Some(String::new()));
   98    100   
        builder
   99    101   
            .build()
  100    102   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  101    103   
    }
  102    104   
}
         105  +
impl InferenceAccelerator {
         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  +
}
  103    116   
impl InferenceAccelerator {
  104    117   
    /// Creates a new builder-style object to manufacture [`InferenceAccelerator`](crate::types::InferenceAccelerator).
  105    118   
    pub fn builder() -> crate::types::builders::InferenceAcceleratorBuilder {
  106    119   
        crate::types::builders::InferenceAcceleratorBuilder::default()
  107    120   
    }
  108    121   
}
  109    122   
  110    123   
/// A builder for [`InferenceAccelerator`](crate::types::InferenceAccelerator).
  111    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    125   
#[non_exhaustive]

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

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

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

@@ -16,16 +178,189 @@
   36     36   
    "com.amazonaws.ecs",
   37     37   
    "InstanceHealthCheckResult",
   38     38   
);
   39     39   
static INSTANCEHEALTHCHECKRESULT_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ecs#InstanceHealthCheckResult$type",
   42     42   
        "com.amazonaws.ecs",
   43     43   
        "InstanceHealthCheckResult",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "r##type",
          46  +
    "type",
   47     47   
    0,
   48     48   
);
   49     49   
static INSTANCEHEALTHCHECKRESULT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.ecs#InstanceHealthCheckResult$status",
   52     52   
        "com.amazonaws.ecs",
   53     53   
        "InstanceHealthCheckResult",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56     56   
    "status",
   57     57   
    1,
   58     58   
);
   59     59   
static INSTANCEHEALTHCHECKRESULT_MEMBER_LAST_UPDATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ecs#InstanceHealthCheckResult$lastUpdated",
   62     62   
        "com.amazonaws.ecs",
   63     63   
        "InstanceHealthCheckResult",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Timestamp,
   66         -
    "last_updated",
          66  +
    "lastUpdated",
   67     67   
    2,
   68     68   
);
   69     69   
static INSTANCEHEALTHCHECKRESULT_MEMBER_LAST_STATUS_CHANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ecs#InstanceHealthCheckResult$lastStatusChange",
   72     72   
        "com.amazonaws.ecs",
   73     73   
        "InstanceHealthCheckResult",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Timestamp,
   76         -
    "last_status_change",
          76  +
    "lastStatusChange",
   77     77   
    3,
   78     78   
);
   79     79   
static INSTANCEHEALTHCHECKRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    INSTANCEHEALTHCHECKRESULT_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &INSTANCEHEALTHCHECKRESULT_MEMBER_TYPE,
   84     84   
        &INSTANCEHEALTHCHECKRESULT_MEMBER_STATUS,
   85     85   
        &INSTANCEHEALTHCHECKRESULT_MEMBER_LAST_UPDATED,
   86     86   
        &INSTANCEHEALTHCHECKRESULT_MEMBER_LAST_STATUS_CHANGE,
   87     87   
    ],
   88     88   
);
   89     89   
impl InstanceHealthCheckResult {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCEHEALTHCHECKRESULT_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceHealthCheckResult {
   94     94   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   95     95   
    fn serialize_members(
   96     96   
        &self,
   97     97   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   98     98   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        if let Some(ref val) = self.r#type {
  100    100   
            ser.write_string(&INSTANCEHEALTHCHECKRESULT_MEMBER_TYPE, val.as_str())?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.status {
  103    103   
            ser.write_string(&INSTANCEHEALTHCHECKRESULT_MEMBER_STATUS, val.as_str())?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.last_updated {
  106    106   
            ser.write_timestamp(&INSTANCEHEALTHCHECKRESULT_MEMBER_LAST_UPDATED, val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.last_status_change {
  109    109   
            ser.write_timestamp(&INSTANCEHEALTHCHECKRESULT_MEMBER_LAST_STATUS_CHANGE, val)?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl InstanceHealthCheckResult {
  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(&INSTANCEHEALTHCHECKRESULT_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&INSTANCEHEALTHCHECKRESULT_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.r#type = Some(crate::types::InstanceHealthCheckType::from(deser.read_string(member)?.as_str()));
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.status = Some(crate::types::InstanceHealthCheckState::from(deser.read_string(member)?.as_str()));
  135    135   
                }
  136    136   
                Some(2) => {
  137    137   
                    builder.last_updated = Some(deser.read_timestamp(member)?);
  138    138   
                }
  139    139   
                Some(3) => {
  140    140   
                    builder.last_status_change = Some(deser.read_timestamp(member)?);
  141    141   
                }
  142    142   
                _ => {}
  143    143   
            }
  144    144   
            Ok(())
  145    145   
        })?;
  146    146   
        Ok(builder.build())
  147    147   
    }
  148    148   
}
         149  +
impl InstanceHealthCheckResult {
         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 InstanceHealthCheckResult {
  150    161   
    /// Creates a new builder-style object to manufacture [`InstanceHealthCheckResult`](crate::types::InstanceHealthCheckResult).
  151    162   
    pub fn builder() -> crate::types::builders::InstanceHealthCheckResultBuilder {
  152    163   
        crate::types::builders::InstanceHealthCheckResultBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`InstanceHealthCheckResult`](crate::types::InstanceHealthCheckResult).
  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/_instance_launch_template.rs

@@ -36,36 +218,230 @@
   56     56   
}
   57     57   
static INSTANCELAUNCHTEMPLATE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#InstanceLaunchTemplate", "com.amazonaws.ecs", "InstanceLaunchTemplate");
   59     59   
static INSTANCELAUNCHTEMPLATE_MEMBER_EC2_INSTANCE_PROFILE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ecs#InstanceLaunchTemplate$ec2InstanceProfileArn",
   62     62   
        "com.amazonaws.ecs",
   63     63   
        "InstanceLaunchTemplate",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "ec2_instance_profile_arn",
          66  +
    "ec2InstanceProfileArn",
   67     67   
    0,
   68     68   
);
   69     69   
static INSTANCELAUNCHTEMPLATE_MEMBER_NETWORK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ecs#InstanceLaunchTemplate$networkConfiguration",
   72     72   
        "com.amazonaws.ecs",
   73     73   
        "InstanceLaunchTemplate",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Structure,
   76         -
    "network_configuration",
          76  +
    "networkConfiguration",
   77     77   
    1,
   78     78   
);
   79     79   
static INSTANCELAUNCHTEMPLATE_MEMBER_STORAGE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ecs#InstanceLaunchTemplate$storageConfiguration",
   82     82   
        "com.amazonaws.ecs",
   83     83   
        "InstanceLaunchTemplate",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86         -
    "storage_configuration",
          86  +
    "storageConfiguration",
   87     87   
    2,
   88     88   
);
   89     89   
static INSTANCELAUNCHTEMPLATE_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ecs#InstanceLaunchTemplate$monitoring",
   92     92   
        "com.amazonaws.ecs",
   93     93   
        "InstanceLaunchTemplate",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96     96   
    "monitoring",
   97     97   
    3,
   98     98   
);
   99     99   
static INSTANCELAUNCHTEMPLATE_MEMBER_INSTANCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ecs#InstanceLaunchTemplate$instanceRequirements",
  102    102   
        "com.amazonaws.ecs",
  103    103   
        "InstanceLaunchTemplate",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106         -
    "instance_requirements",
         106  +
    "instanceRequirements",
  107    107   
    4,
  108    108   
);
  109    109   
static INSTANCELAUNCHTEMPLATE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  110    110   
    INSTANCELAUNCHTEMPLATE_SCHEMA_ID,
  111    111   
    ::aws_smithy_schema::ShapeType::Structure,
  112    112   
    &[
  113    113   
        &INSTANCELAUNCHTEMPLATE_MEMBER_EC2_INSTANCE_PROFILE_ARN,
  114    114   
        &INSTANCELAUNCHTEMPLATE_MEMBER_NETWORK_CONFIGURATION,
  115    115   
        &INSTANCELAUNCHTEMPLATE_MEMBER_STORAGE_CONFIGURATION,
  116    116   
        &INSTANCELAUNCHTEMPLATE_MEMBER_MONITORING,
  117    117   
        &INSTANCELAUNCHTEMPLATE_MEMBER_INSTANCE_REQUIREMENTS,
  118    118   
    ],
  119    119   
);
  120    120   
impl InstanceLaunchTemplate {
  121    121   
    /// The schema for this shape.
  122    122   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSTANCELAUNCHTEMPLATE_SCHEMA;
  123    123   
}
  124    124   
impl ::aws_smithy_schema::serde::SerializableStruct for InstanceLaunchTemplate {
  125    125   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  126    126   
    fn serialize_members(
  127    127   
        &self,
  128    128   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  129    129   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  130    130   
        {
  131    131   
            let val = &self.ec2_instance_profile_arn;
  132    132   
            ser.write_string(&INSTANCELAUNCHTEMPLATE_MEMBER_EC2_INSTANCE_PROFILE_ARN, val)?;
  133    133   
        }
  134    134   
        if let Some(ref val) = self.network_configuration {
  135    135   
            ser.write_struct(&INSTANCELAUNCHTEMPLATE_MEMBER_NETWORK_CONFIGURATION, val)?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.storage_configuration {
  138    138   
            ser.write_struct(&INSTANCELAUNCHTEMPLATE_MEMBER_STORAGE_CONFIGURATION, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.monitoring {
  141    141   
            ser.write_string(&INSTANCELAUNCHTEMPLATE_MEMBER_MONITORING, val.as_str())?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.instance_requirements {
  144    144   
            ser.write_struct(&INSTANCELAUNCHTEMPLATE_MEMBER_INSTANCE_REQUIREMENTS, val)?;
  145    145   
        }
  146    146   
        Ok(())
  147    147   
    }
  148    148   
}
  149    149   
impl InstanceLaunchTemplate {
  150    150   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  151         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  152         -
        deserializer: &mut D,
         151  +
    pub fn deserialize(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  153    153   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        #[allow(unused_variables, unused_mut)]
  155    155   
        let mut builder = Self::builder();
  156    156   
        #[allow(
  157    157   
            unused_variables,
  158    158   
            unreachable_code,
  159    159   
            clippy::single_match,
  160    160   
            clippy::match_single_binding,
  161    161   
            clippy::diverging_sub_expression
  162    162   
        )]
  163         -
        deserializer.read_struct(&INSTANCELAUNCHTEMPLATE_SCHEMA, (), |_, member, deser| {
         163  +
        deserializer.read_struct(&INSTANCELAUNCHTEMPLATE_SCHEMA, &mut |member, deser| {
  164    164   
            match member.member_index() {
  165    165   
                Some(0) => {
  166    166   
                    builder.ec2_instance_profile_arn = Some(deser.read_string(member)?);
  167    167   
                }
  168    168   
                Some(1) => {
  169    169   
                    builder.network_configuration = Some(crate::types::ManagedInstancesNetworkConfiguration::deserialize(deser)?);
  170    170   
                }
  171    171   
                Some(2) => {
  172    172   
                    builder.storage_configuration = Some(crate::types::ManagedInstancesStorageConfiguration::deserialize(deser)?);
  173    173   
                }
  174    174   
                Some(3) => {
  175    175   
                    builder.monitoring = Some(crate::types::ManagedInstancesMonitoringOptions::from(deser.read_string(member)?.as_str()));
  176    176   
                }
  177    177   
                Some(4) => {
  178    178   
                    builder.instance_requirements = Some(crate::types::InstanceRequirementsRequest::deserialize(deser)?);
  179    179   
                }
  180    180   
                _ => {}
  181    181   
            }
  182    182   
            Ok(())
  183    183   
        })?;
         184  +
        builder.ec2_instance_profile_arn = builder.ec2_instance_profile_arn.or(Some(String::new()));
  184    185   
        builder
  185    186   
            .build()
  186    187   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  187    188   
    }
  188    189   
}
         190  +
impl InstanceLaunchTemplate {
         191  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         192  +
    pub fn deserialize_with_response(
         193  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         194  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         195  +
        _status: u16,
         196  +
        _body: &[u8],
         197  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         198  +
        Self::deserialize(deserializer)
         199  +
    }
         200  +
}
  189    201   
impl InstanceLaunchTemplate {
  190    202   
    /// Creates a new builder-style object to manufacture [`InstanceLaunchTemplate`](crate::types::InstanceLaunchTemplate).
  191    203   
    pub fn builder() -> crate::types::builders::InstanceLaunchTemplateBuilder {
  192    204   
        crate::types::builders::InstanceLaunchTemplateBuilder::default()
  193    205   
    }
  194    206   
}
  195    207   
  196    208   
/// A builder for [`InstanceLaunchTemplate`](crate::types::InstanceLaunchTemplate).
  197    209   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  198    210   
#[non_exhaustive]

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

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

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

@@ -152,152 +453,453 @@
  172    172   
    "com.amazonaws.ecs",
  173    173   
    "InstanceRequirementsRequest",
  174    174   
);
  175    175   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_V_CPU_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  176    176   
    ::aws_smithy_schema::ShapeId::from_static(
  177    177   
        "com.amazonaws.ecs#InstanceRequirementsRequest$vCpuCount",
  178    178   
        "com.amazonaws.ecs",
  179    179   
        "InstanceRequirementsRequest",
  180    180   
    ),
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182         -
    "v_cpu_count",
         182  +
    "vCpuCount",
  183    183   
    0,
  184    184   
);
  185    185   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_MEMORY_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static(
  187    187   
        "com.amazonaws.ecs#InstanceRequirementsRequest$memoryMiB",
  188    188   
        "com.amazonaws.ecs",
  189    189   
        "InstanceRequirementsRequest",
  190    190   
    ),
  191    191   
    ::aws_smithy_schema::ShapeType::Structure,
  192         -
    "memory_mib",
         192  +
    "memoryMiB",
  193    193   
    1,
  194    194   
);
  195    195   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_CPU_MANUFACTURERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static(
  197    197   
        "com.amazonaws.ecs#InstanceRequirementsRequest$cpuManufacturers",
  198    198   
        "com.amazonaws.ecs",
  199    199   
        "InstanceRequirementsRequest",
  200    200   
    ),
  201    201   
    ::aws_smithy_schema::ShapeType::List,
  202         -
    "cpu_manufacturers",
         202  +
    "cpuManufacturers",
  203    203   
    2,
  204    204   
)
  205    205   
.with_xml_name("CpuManufacturer");
  206    206   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_MEMORY_GIB_PER_V_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.ecs#InstanceRequirementsRequest$memoryGiBPerVCpu",
  209    209   
        "com.amazonaws.ecs",
  210    210   
        "InstanceRequirementsRequest",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::Structure,
  213         -
    "memory_gib_per_v_cpu",
         213  +
    "memoryGiBPerVCpu",
  214    214   
    3,
  215    215   
);
  216    216   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_EXCLUDED_INSTANCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.ecs#InstanceRequirementsRequest$excludedInstanceTypes",
  219    219   
        "com.amazonaws.ecs",
  220    220   
        "InstanceRequirementsRequest",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::List,
  223         -
    "excluded_instance_types",
         223  +
    "excludedInstanceTypes",
  224    224   
    4,
  225    225   
)
  226    226   
.with_xml_name("ExcludedInstanceType");
  227    227   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_INSTANCE_GENERATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static(
  229    229   
        "com.amazonaws.ecs#InstanceRequirementsRequest$instanceGenerations",
  230    230   
        "com.amazonaws.ecs",
  231    231   
        "InstanceRequirementsRequest",
  232    232   
    ),
  233    233   
    ::aws_smithy_schema::ShapeType::List,
  234         -
    "instance_generations",
         234  +
    "instanceGenerations",
  235    235   
    5,
  236    236   
)
  237    237   
.with_xml_name("InstanceGeneration");
  238    238   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_SPOT_MAX_PRICE_PERCENTAGE_OVER_LOWEST_PRICE: ::aws_smithy_schema::Schema =
  239    239   
    ::aws_smithy_schema::Schema::new_member(
  240    240   
        ::aws_smithy_schema::ShapeId::from_static(
  241    241   
            "com.amazonaws.ecs#InstanceRequirementsRequest$spotMaxPricePercentageOverLowestPrice",
  242    242   
            "com.amazonaws.ecs",
  243    243   
            "InstanceRequirementsRequest",
  244    244   
        ),
  245    245   
        ::aws_smithy_schema::ShapeType::Integer,
  246         -
        "spot_max_price_percentage_over_lowest_price",
         246  +
        "spotMaxPricePercentageOverLowestPrice",
  247    247   
        6,
  248    248   
    );
  249    249   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ON_DEMAND_MAX_PRICE_PERCENTAGE_OVER_LOWEST_PRICE: ::aws_smithy_schema::Schema =
  250    250   
    ::aws_smithy_schema::Schema::new_member(
  251    251   
        ::aws_smithy_schema::ShapeId::from_static(
  252    252   
            "com.amazonaws.ecs#InstanceRequirementsRequest$onDemandMaxPricePercentageOverLowestPrice",
  253    253   
            "com.amazonaws.ecs",
  254    254   
            "InstanceRequirementsRequest",
  255    255   
        ),
  256    256   
        ::aws_smithy_schema::ShapeType::Integer,
  257         -
        "on_demand_max_price_percentage_over_lowest_price",
         257  +
        "onDemandMaxPricePercentageOverLowestPrice",
  258    258   
        7,
  259    259   
    );
  260    260   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_BARE_METAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  261    261   
    ::aws_smithy_schema::ShapeId::from_static(
  262    262   
        "com.amazonaws.ecs#InstanceRequirementsRequest$bareMetal",
  263    263   
        "com.amazonaws.ecs",
  264    264   
        "InstanceRequirementsRequest",
  265    265   
    ),
  266    266   
    ::aws_smithy_schema::ShapeType::String,
  267         -
    "bare_metal",
         267  +
    "bareMetal",
  268    268   
    8,
  269    269   
);
  270    270   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_BURSTABLE_PERFORMANCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  271    271   
    ::aws_smithy_schema::ShapeId::from_static(
  272    272   
        "com.amazonaws.ecs#InstanceRequirementsRequest$burstablePerformance",
  273    273   
        "com.amazonaws.ecs",
  274    274   
        "InstanceRequirementsRequest",
  275    275   
    ),
  276    276   
    ::aws_smithy_schema::ShapeType::String,
  277         -
    "burstable_performance",
         277  +
    "burstablePerformance",
  278    278   
    9,
  279    279   
);
  280    280   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_REQUIRE_HIBERNATE_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  281    281   
    ::aws_smithy_schema::ShapeId::from_static(
  282    282   
        "com.amazonaws.ecs#InstanceRequirementsRequest$requireHibernateSupport",
  283    283   
        "com.amazonaws.ecs",
  284    284   
        "InstanceRequirementsRequest",
  285    285   
    ),
  286    286   
    ::aws_smithy_schema::ShapeType::Boolean,
  287         -
    "require_hibernate_support",
         287  +
    "requireHibernateSupport",
  288    288   
    10,
  289    289   
);
  290    290   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_NETWORK_INTERFACE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  291    291   
    ::aws_smithy_schema::ShapeId::from_static(
  292    292   
        "com.amazonaws.ecs#InstanceRequirementsRequest$networkInterfaceCount",
  293    293   
        "com.amazonaws.ecs",
  294    294   
        "InstanceRequirementsRequest",
  295    295   
    ),
  296    296   
    ::aws_smithy_schema::ShapeType::Structure,
  297         -
    "network_interface_count",
         297  +
    "networkInterfaceCount",
  298    298   
    11,
  299    299   
);
  300    300   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_LOCAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  301    301   
    ::aws_smithy_schema::ShapeId::from_static(
  302    302   
        "com.amazonaws.ecs#InstanceRequirementsRequest$localStorage",
  303    303   
        "com.amazonaws.ecs",
  304    304   
        "InstanceRequirementsRequest",
  305    305   
    ),
  306    306   
    ::aws_smithy_schema::ShapeType::String,
  307         -
    "local_storage",
         307  +
    "localStorage",
  308    308   
    12,
  309    309   
);
  310    310   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_LOCAL_STORAGE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  311    311   
    ::aws_smithy_schema::ShapeId::from_static(
  312    312   
        "com.amazonaws.ecs#InstanceRequirementsRequest$localStorageTypes",
  313    313   
        "com.amazonaws.ecs",
  314    314   
        "InstanceRequirementsRequest",
  315    315   
    ),
  316    316   
    ::aws_smithy_schema::ShapeType::List,
  317         -
    "local_storage_types",
         317  +
    "localStorageTypes",
  318    318   
    13,
  319    319   
)
  320    320   
.with_xml_name("LocalStorageType");
  321    321   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_TOTAL_LOCAL_STORAGE_GB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  322    322   
    ::aws_smithy_schema::ShapeId::from_static(
  323    323   
        "com.amazonaws.ecs#InstanceRequirementsRequest$totalLocalStorageGB",
  324    324   
        "com.amazonaws.ecs",
  325    325   
        "InstanceRequirementsRequest",
  326    326   
    ),
  327    327   
    ::aws_smithy_schema::ShapeType::Structure,
  328         -
    "total_local_storage_gb",
         328  +
    "totalLocalStorageGB",
  329    329   
    14,
  330    330   
);
  331    331   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_BASELINE_EBS_BANDWIDTH_MBPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  332    332   
    ::aws_smithy_schema::ShapeId::from_static(
  333    333   
        "com.amazonaws.ecs#InstanceRequirementsRequest$baselineEbsBandwidthMbps",
  334    334   
        "com.amazonaws.ecs",
  335    335   
        "InstanceRequirementsRequest",
  336    336   
    ),
  337    337   
    ::aws_smithy_schema::ShapeType::Structure,
  338         -
    "baseline_ebs_bandwidth_mbps",
         338  +
    "baselineEbsBandwidthMbps",
  339    339   
    15,
  340    340   
);
  341    341   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ACCELERATOR_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  342    342   
    ::aws_smithy_schema::ShapeId::from_static(
  343    343   
        "com.amazonaws.ecs#InstanceRequirementsRequest$acceleratorTypes",
  344    344   
        "com.amazonaws.ecs",
  345    345   
        "InstanceRequirementsRequest",
  346    346   
    ),
  347    347   
    ::aws_smithy_schema::ShapeType::List,
  348         -
    "accelerator_types",
         348  +
    "acceleratorTypes",
  349    349   
    16,
  350    350   
)
  351    351   
.with_xml_name("AcceleratorType");
  352    352   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ACCELERATOR_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  353    353   
    ::aws_smithy_schema::ShapeId::from_static(
  354    354   
        "com.amazonaws.ecs#InstanceRequirementsRequest$acceleratorCount",
  355    355   
        "com.amazonaws.ecs",
  356    356   
        "InstanceRequirementsRequest",
  357    357   
    ),
  358    358   
    ::aws_smithy_schema::ShapeType::Structure,
  359         -
    "accelerator_count",
         359  +
    "acceleratorCount",
  360    360   
    17,
  361    361   
);
  362    362   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ACCELERATOR_MANUFACTURERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  363    363   
    ::aws_smithy_schema::ShapeId::from_static(
  364    364   
        "com.amazonaws.ecs#InstanceRequirementsRequest$acceleratorManufacturers",
  365    365   
        "com.amazonaws.ecs",
  366    366   
        "InstanceRequirementsRequest",
  367    367   
    ),
  368    368   
    ::aws_smithy_schema::ShapeType::List,
  369         -
    "accelerator_manufacturers",
         369  +
    "acceleratorManufacturers",
  370    370   
    18,
  371    371   
)
  372    372   
.with_xml_name("AcceleratorManufacturer");
  373    373   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ACCELERATOR_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  374    374   
    ::aws_smithy_schema::ShapeId::from_static(
  375    375   
        "com.amazonaws.ecs#InstanceRequirementsRequest$acceleratorNames",
  376    376   
        "com.amazonaws.ecs",
  377    377   
        "InstanceRequirementsRequest",
  378    378   
    ),
  379    379   
    ::aws_smithy_schema::ShapeType::List,
  380         -
    "accelerator_names",
         380  +
    "acceleratorNames",
  381    381   
    19,
  382    382   
)
  383    383   
.with_xml_name("AcceleratorName");
  384    384   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ACCELERATOR_TOTAL_MEMORY_MIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  385    385   
    ::aws_smithy_schema::ShapeId::from_static(
  386    386   
        "com.amazonaws.ecs#InstanceRequirementsRequest$acceleratorTotalMemoryMiB",
  387    387   
        "com.amazonaws.ecs",
  388    388   
        "InstanceRequirementsRequest",
  389    389   
    ),
  390    390   
    ::aws_smithy_schema::ShapeType::Structure,
  391         -
    "accelerator_total_memory_mib",
         391  +
    "acceleratorTotalMemoryMiB",
  392    392   
    20,
  393    393   
);
  394    394   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_NETWORK_BANDWIDTH_GBPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  395    395   
    ::aws_smithy_schema::ShapeId::from_static(
  396    396   
        "com.amazonaws.ecs#InstanceRequirementsRequest$networkBandwidthGbps",
  397    397   
        "com.amazonaws.ecs",
  398    398   
        "InstanceRequirementsRequest",
  399    399   
    ),
  400    400   
    ::aws_smithy_schema::ShapeType::Structure,
  401         -
    "network_bandwidth_gbps",
         401  +
    "networkBandwidthGbps",
  402    402   
    21,
  403    403   
);
  404    404   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_ALLOWED_INSTANCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  405    405   
    ::aws_smithy_schema::ShapeId::from_static(
  406    406   
        "com.amazonaws.ecs#InstanceRequirementsRequest$allowedInstanceTypes",
  407    407   
        "com.amazonaws.ecs",
  408    408   
        "InstanceRequirementsRequest",
  409    409   
    ),
  410    410   
    ::aws_smithy_schema::ShapeType::List,
  411         -
    "allowed_instance_types",
         411  +
    "allowedInstanceTypes",
  412    412   
    22,
  413    413   
)
  414    414   
.with_xml_name("AllowedInstanceType");
  415    415   
static INSTANCEREQUIREMENTSREQUEST_MEMBER_MAX_SPOT_PRICE_AS_PERCENTAGE_OF_OPTIMAL_ON_DEMAND_PRICE: ::aws_smithy_schema::Schema =
  416    416   
    ::aws_smithy_schema::Schema::new_member(
  417    417   
        ::aws_smithy_schema::ShapeId::from_static(
  418    418   
            "com.amazonaws.ecs#InstanceRequirementsRequest$maxSpotPriceAsPercentageOfOptimalOnDemandPrice",
  419    419   
            "com.amazonaws.ecs",
  420    420   
            "InstanceRequirementsRequest",
  421    421   
        ),
  422    422   
        ::aws_smithy_schema::ShapeType::Integer,
  423         -
        "max_spot_price_as_percentage_of_optimal_on_demand_price",
         423  +
        "maxSpotPriceAsPercentageOfOptimalOnDemandPrice",
  424    424   
        23,
  425    425   
    );
  426    426   
static INSTANCEREQUIREMENTSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  427    427   
    INSTANCEREQUIREMENTSREQUEST_SCHEMA_ID,
  428    428   
    ::aws_smithy_schema::ShapeType::Structure,
  429    429   
    &[
  430    430   
        &INSTANCEREQUIREMENTSREQUEST_MEMBER_V_CPU_COUNT,
  431    431   
        &INSTANCEREQUIREMENTSREQUEST_MEMBER_MEMORY_MIB,
  432    432   
        &INSTANCEREQUIREMENTSREQUEST_MEMBER_CPU_MANUFACTURERS,
  433    433   
        &INSTANCEREQUIREMENTSREQUEST_MEMBER_MEMORY_GIB_PER_V_CPU,
@@ -580,580 +812,785 @@
  600    600   
            ser.write_integer(
  601    601   
                &INSTANCEREQUIREMENTSREQUEST_MEMBER_MAX_SPOT_PRICE_AS_PERCENTAGE_OF_OPTIMAL_ON_DEMAND_PRICE,
  602    602   
                *val,
  603    603   
            )?;
  604    604   
        }
  605    605   
        Ok(())
  606    606   
    }
  607    607   
}
  608    608   
impl InstanceRequirementsRequest {
  609    609   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  610         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  611         -
        deserializer: &mut D,
         610  +
    pub fn deserialize(
         611  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  612    612   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  613    613   
        #[allow(unused_variables, unused_mut)]
  614    614   
        let mut builder = Self::builder();
  615    615   
        #[allow(
  616    616   
            unused_variables,
  617    617   
            unreachable_code,
  618    618   
            clippy::single_match,
  619    619   
            clippy::match_single_binding,
  620    620   
            clippy::diverging_sub_expression
  621    621   
        )]
  622         -
        deserializer.read_struct(&INSTANCEREQUIREMENTSREQUEST_SCHEMA, (), |_, member, deser| {
         622  +
        deserializer.read_struct(&INSTANCEREQUIREMENTSREQUEST_SCHEMA, &mut |member, deser| {
  623    623   
            match member.member_index() {
  624    624   
                Some(0) => {
  625    625   
                    builder.v_cpu_count = Some(crate::types::VCpuCountRangeRequest::deserialize(deser)?);
  626    626   
                }
  627    627   
                Some(1) => {
  628    628   
                    builder.memory_mib = Some(crate::types::MemoryMiBRequest::deserialize(deser)?);
  629    629   
                }
  630    630   
                Some(2) => {
  631    631   
                    builder.cpu_manufacturers = Some({
  632         -
                        let container = if let Some(cap) = deser.container_size() {
  633         -
                            Vec::with_capacity(cap)
  634         -
                        } else {
  635         -
                            Vec::new()
  636         -
                        };
  637         -
                        deser.read_list(member, container, |mut list, deser| {
  638         -
                            list.push(crate::types::CpuManufacturer::from(deser.read_string(member)?.as_str()));
  639         -
                            Ok(list)
  640         -
                        })?
         632  +
                        let mut container = Vec::new();
         633  +
                        deser.read_list(member, &mut |deser| {
         634  +
                            container.push(crate::types::CpuManufacturer::from(deser.read_string(member)?.as_str()));
         635  +
                            Ok(())
         636  +
                        })?;
         637  +
                        container
  641    638   
                    });
  642    639   
                }
  643    640   
                Some(3) => {
  644    641   
                    builder.memory_gib_per_v_cpu = Some(crate::types::MemoryGiBPerVCpuRequest::deserialize(deser)?);
  645    642   
                }
  646    643   
                Some(4) => {
  647         -
                    builder.excluded_instance_types = Some({
  648         -
                        let container = if let Some(cap) = deser.container_size() {
  649         -
                            Vec::with_capacity(cap)
  650         -
                        } else {
  651         -
                            Vec::new()
  652         -
                        };
  653         -
                        deser.read_list(member, container, |mut list, deser| {
  654         -
                            list.push(deser.read_string(member)?);
  655         -
                            Ok(list)
  656         -
                        })?
  657         -
                    });
         644  +
                    builder.excluded_instance_types = Some(deser.read_string_list(member)?);
  658    645   
                }
  659    646   
                Some(5) => {
  660    647   
                    builder.instance_generations = Some({
  661         -
                        let container = if let Some(cap) = deser.container_size() {
  662         -
                            Vec::with_capacity(cap)
  663         -
                        } else {
  664         -
                            Vec::new()
  665         -
                        };
  666         -
                        deser.read_list(member, container, |mut list, deser| {
  667         -
                            list.push(crate::types::InstanceGeneration::from(deser.read_string(member)?.as_str()));
  668         -
                            Ok(list)
  669         -
                        })?
         648  +
                        let mut container = Vec::new();
         649  +
                        deser.read_list(member, &mut |deser| {
         650  +
                            container.push(crate::types::InstanceGeneration::from(deser.read_string(member)?.as_str()));
         651  +
                            Ok(())
         652  +
                        })?;
         653  +
                        container
  670    654   
                    });
  671    655   
                }
  672    656   
                Some(6) => {
  673    657   
                    builder.spot_max_price_percentage_over_lowest_price = Some(deser.read_integer(member)?);
  674    658   
                }
  675    659   
                Some(7) => {
  676    660   
                    builder.on_demand_max_price_percentage_over_lowest_price = Some(deser.read_integer(member)?);
  677    661   
                }
  678    662   
                Some(8) => {
  679    663   
                    builder.bare_metal = Some(crate::types::BareMetal::from(deser.read_string(member)?.as_str()));
  680    664   
                }
  681    665   
                Some(9) => {
  682    666   
                    builder.burstable_performance = Some(crate::types::BurstablePerformance::from(deser.read_string(member)?.as_str()));
  683    667   
                }
  684    668   
                Some(10) => {
  685    669   
                    builder.require_hibernate_support = Some(deser.read_boolean(member)?);
  686    670   
                }
  687    671   
                Some(11) => {
  688    672   
                    builder.network_interface_count = Some(crate::types::NetworkInterfaceCountRequest::deserialize(deser)?);
  689    673   
                }
  690    674   
                Some(12) => {
  691    675   
                    builder.local_storage = Some(crate::types::LocalStorage::from(deser.read_string(member)?.as_str()));
  692    676   
                }
  693    677   
                Some(13) => {
  694    678   
                    builder.local_storage_types = Some({
  695         -
                        let container = if let Some(cap) = deser.container_size() {
  696         -
                            Vec::with_capacity(cap)
  697         -
                        } else {
  698         -
                            Vec::new()
  699         -
                        };
  700         -
                        deser.read_list(member, container, |mut list, deser| {
  701         -
                            list.push(crate::types::LocalStorageType::from(deser.read_string(member)?.as_str()));
  702         -
                            Ok(list)
  703         -
                        })?
         679  +
                        let mut container = Vec::new();
         680  +
                        deser.read_list(member, &mut |deser| {
         681  +
                            container.push(crate::types::LocalStorageType::from(deser.read_string(member)?.as_str()));
         682  +
                            Ok(())
         683  +
                        })?;
         684  +
                        container
  704    685   
                    });
  705    686   
                }
  706    687   
                Some(14) => {
  707    688   
                    builder.total_local_storage_gb = Some(crate::types::TotalLocalStorageGbRequest::deserialize(deser)?);
  708    689   
                }
  709    690   
                Some(15) => {
  710    691   
                    builder.baseline_ebs_bandwidth_mbps = Some(crate::types::BaselineEbsBandwidthMbpsRequest::deserialize(deser)?);
  711    692   
                }
  712    693   
                Some(16) => {
  713    694   
                    builder.accelerator_types = Some({
  714         -
                        let container = if let Some(cap) = deser.container_size() {
  715         -
                            Vec::with_capacity(cap)
  716         -
                        } else {
  717         -
                            Vec::new()
  718         -
                        };
  719         -
                        deser.read_list(member, container, |mut list, deser| {
  720         -
                            list.push(crate::types::AcceleratorType::from(deser.read_string(member)?.as_str()));
  721         -
                            Ok(list)
  722         -
                        })?
         695  +
                        let mut container = Vec::new();
         696  +
                        deser.read_list(member, &mut |deser| {
         697  +
                            container.push(crate::types::AcceleratorType::from(deser.read_string(member)?.as_str()));
         698  +
                            Ok(())
         699  +
                        })?;
         700  +
                        container
  723    701   
                    });
  724    702   
                }
  725    703   
                Some(17) => {
  726    704   
                    builder.accelerator_count = Some(crate::types::AcceleratorCountRequest::deserialize(deser)?);
  727    705   
                }
  728    706   
                Some(18) => {
  729    707   
                    builder.accelerator_manufacturers = Some({
  730         -
                        let container = if let Some(cap) = deser.container_size() {
  731         -
                            Vec::with_capacity(cap)
  732         -
                        } else {
  733         -
                            Vec::new()
  734         -
                        };
  735         -
                        deser.read_list(member, container, |mut list, deser| {
  736         -
                            list.push(crate::types::AcceleratorManufacturer::from(deser.read_string(member)?.as_str()));
  737         -
                            Ok(list)
  738         -
                        })?
         708  +
                        let mut container = Vec::new();
         709  +
                        deser.read_list(member, &mut |deser| {
         710  +
                            container.push(crate::types::AcceleratorManufacturer::from(deser.read_string(member)?.as_str()));
         711  +
                            Ok(())
         712  +
                        })?;
         713  +
                        container
  739    714   
                    });
  740    715   
                }
  741    716   
                Some(19) => {
  742    717   
                    builder.accelerator_names = Some({
  743         -
                        let container = if let Some(cap) = deser.container_size() {
  744         -
                            Vec::with_capacity(cap)
  745         -
                        } else {
  746         -
                            Vec::new()
  747         -
                        };
  748         -
                        deser.read_list(member, container, |mut list, deser| {
  749         -
                            list.push(crate::types::AcceleratorName::from(deser.read_string(member)?.as_str()));
  750         -
                            Ok(list)
  751         -
                        })?
         718  +
                        let mut container = Vec::new();
         719  +
                        deser.read_list(member, &mut |deser| {
         720  +
                            container.push(crate::types::AcceleratorName::from(deser.read_string(member)?.as_str()));
         721  +
                            Ok(())
         722  +
                        })?;
         723  +
                        container
  752    724   
                    });
  753    725   
                }
  754    726   
                Some(20) => {
  755    727   
                    builder.accelerator_total_memory_mib = Some(crate::types::AcceleratorTotalMemoryMiBRequest::deserialize(deser)?);
  756    728   
                }
  757    729   
                Some(21) => {
  758    730   
                    builder.network_bandwidth_gbps = Some(crate::types::NetworkBandwidthGbpsRequest::deserialize(deser)?);
  759    731   
                }
  760    732   
                Some(22) => {
  761         -
                    builder.allowed_instance_types = Some({
  762         -
                        let container = if let Some(cap) = deser.container_size() {
  763         -
                            Vec::with_capacity(cap)
  764         -
                        } else {
  765         -
                            Vec::new()
  766         -
                        };
  767         -
                        deser.read_list(member, container, |mut list, deser| {
  768         -
                            list.push(deser.read_string(member)?);
  769         -
                            Ok(list)
  770         -
                        })?
  771         -
                    });
         733  +
                    builder.allowed_instance_types = Some(deser.read_string_list(member)?);
  772    734   
                }
  773    735   
                Some(23) => {
  774    736   
                    builder.max_spot_price_as_percentage_of_optimal_on_demand_price = Some(deser.read_integer(member)?);
  775    737   
                }
  776    738   
                _ => {}
  777    739   
            }
  778    740   
            Ok(())
  779    741   
        })?;
  780    742   
        Ok(builder.build())
  781    743   
    }
  782    744   
}
         745  +
impl InstanceRequirementsRequest {
         746  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         747  +
    pub fn deserialize_with_response(
         748  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         749  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         750  +
        _status: u16,
         751  +
        _body: &[u8],
         752  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         753  +
        Self::deserialize(deserializer)
         754  +
    }
         755  +
}
  783    756   
impl InstanceRequirementsRequest {
  784    757   
    /// Creates a new builder-style object to manufacture [`InstanceRequirementsRequest`](crate::types::InstanceRequirementsRequest).
  785    758   
    pub fn builder() -> crate::types::builders::InstanceRequirementsRequestBuilder {
  786    759   
        crate::types::builders::InstanceRequirementsRequestBuilder::default()
  787    760   
    }
  788    761   
}
  789    762   
  790    763   
/// A builder for [`InstanceRequirementsRequest`](crate::types::InstanceRequirementsRequest).
  791    764   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  792    765   
#[non_exhaustive]

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

@@ -73,73 +179,170 @@
   93     93   
                    }
   94     94   
                    Ok(())
   95     95   
                },
   96     96   
            )?;
   97     97   
        }
   98     98   
        Ok(())
   99     99   
    }
  100    100   
}
  101    101   
impl KernelCapabilities {
  102    102   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  103         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  104         -
        deserializer: &mut D,
         103  +
    pub fn deserialize(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  105    105   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        #[allow(unused_variables, unused_mut)]
  107    107   
        let mut builder = Self::builder();
  108    108   
        #[allow(
  109    109   
            unused_variables,
  110    110   
            unreachable_code,
  111    111   
            clippy::single_match,
  112    112   
            clippy::match_single_binding,
  113    113   
            clippy::diverging_sub_expression
  114    114   
        )]
  115         -
        deserializer.read_struct(&KERNELCAPABILITIES_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&KERNELCAPABILITIES_SCHEMA, &mut |member, deser| {
  116    116   
            match member.member_index() {
  117    117   
                Some(0) => {
  118         -
                    builder.add = Some({
  119         -
                        let container = if let Some(cap) = deser.container_size() {
  120         -
                            Vec::with_capacity(cap)
  121         -
                        } else {
  122         -
                            Vec::new()
  123         -
                        };
  124         -
                        deser.read_list(member, container, |mut list, deser| {
  125         -
                            list.push(deser.read_string(member)?);
  126         -
                            Ok(list)
  127         -
                        })?
  128         -
                    });
         118  +
                    builder.add = Some(deser.read_string_list(member)?);
  129    119   
                }
  130    120   
                Some(1) => {
  131         -
                    builder.drop = Some({
  132         -
                        let container = if let Some(cap) = deser.container_size() {
  133         -
                            Vec::with_capacity(cap)
  134         -
                        } else {
  135         -
                            Vec::new()
  136         -
                        };
  137         -
                        deser.read_list(member, container, |mut list, deser| {
  138         -
                            list.push(deser.read_string(member)?);
  139         -
                            Ok(list)
  140         -
                        })?
  141         -
                    });
         121  +
                    builder.drop = Some(deser.read_string_list(member)?);
  142    122   
                }
  143    123   
                _ => {}
  144    124   
            }
  145    125   
            Ok(())
  146    126   
        })?;
  147    127   
        Ok(builder.build())
  148    128   
    }
  149    129   
}
         130  +
impl KernelCapabilities {
         131  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         132  +
    pub fn deserialize_with_response(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         134  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         135  +
        _status: u16,
         136  +
        _body: &[u8],
         137  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         138  +
        Self::deserialize(deserializer)
         139  +
    }
         140  +
}
  150    141   
impl KernelCapabilities {
  151    142   
    /// Creates a new builder-style object to manufacture [`KernelCapabilities`](crate::types::KernelCapabilities).
  152    143   
    pub fn builder() -> crate::types::builders::KernelCapabilitiesBuilder {
  153    144   
        crate::types::builders::KernelCapabilitiesBuilder::default()
  154    145   
    }
  155    146   
}
  156    147   
  157    148   
/// A builder for [`KernelCapabilities`](crate::types::KernelCapabilities).
  158    149   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  159    150   
#[non_exhaustive]

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

@@ -32,32 +118,129 @@
   52     52   
            ser.write_string(&KEYVALUEPAIR_MEMBER_NAME, val)?;
   53     53   
        }
   54     54   
        if let Some(ref val) = self.value {
   55     55   
            ser.write_string(&KEYVALUEPAIR_MEMBER_VALUE, val)?;
   56     56   
        }
   57     57   
        Ok(())
   58     58   
    }
   59     59   
}
   60     60   
impl KeyValuePair {
   61     61   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   62         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   63         -
        deserializer: &mut D,
          62  +
    pub fn deserialize(
          63  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   64     64   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        #[allow(unused_variables, unused_mut)]
   66     66   
        let mut builder = Self::builder();
   67     67   
        #[allow(
   68     68   
            unused_variables,
   69     69   
            unreachable_code,
   70     70   
            clippy::single_match,
   71     71   
            clippy::match_single_binding,
   72     72   
            clippy::diverging_sub_expression
   73     73   
        )]
   74         -
        deserializer.read_struct(&KEYVALUEPAIR_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&KEYVALUEPAIR_SCHEMA, &mut |member, deser| {
   75     75   
            match member.member_index() {
   76     76   
                Some(0) => {
   77     77   
                    builder.name = Some(deser.read_string(member)?);
   78     78   
                }
   79     79   
                Some(1) => {
   80     80   
                    builder.value = Some(deser.read_string(member)?);
   81     81   
                }
   82     82   
                _ => {}
   83     83   
            }
   84     84   
            Ok(())
   85     85   
        })?;
   86     86   
        Ok(builder.build())
   87     87   
    }
   88     88   
}
          89  +
impl KeyValuePair {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          91  +
    pub fn deserialize_with_response(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          93  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          94  +
        _status: u16,
          95  +
        _body: &[u8],
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        Self::deserialize(deserializer)
          98  +
    }
          99  +
}
   89    100   
impl KeyValuePair {
   90    101   
    /// Creates a new builder-style object to manufacture [`KeyValuePair`](crate::types::KeyValuePair).
   91    102   
    pub fn builder() -> crate::types::builders::KeyValuePairBuilder {
   92    103   
        crate::types::builders::KeyValuePairBuilder::default()
   93    104   
    }
   94    105   
}
   95    106   
   96    107   
/// A builder for [`KeyValuePair`](crate::types::KeyValuePair).
   97    108   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   98    109   
#[non_exhaustive]

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

@@ -77,77 +159,159 @@
   97     97   
    "devices",
   98     98   
    1,
   99     99   
);
  100    100   
static LINUXPARAMETERS_MEMBER_INIT_PROCESS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.ecs#LinuxParameters$initProcessEnabled",
  103    103   
        "com.amazonaws.ecs",
  104    104   
        "LinuxParameters",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::Boolean,
  107         -
    "init_process_enabled",
         107  +
    "initProcessEnabled",
  108    108   
    2,
  109    109   
);
  110    110   
static LINUXPARAMETERS_MEMBER_SHARED_MEMORY_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.ecs#LinuxParameters$sharedMemorySize",
  113    113   
        "com.amazonaws.ecs",
  114    114   
        "LinuxParameters",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::Integer,
  117         -
    "shared_memory_size",
         117  +
    "sharedMemorySize",
  118    118   
    3,
  119    119   
);
  120    120   
static LINUXPARAMETERS_MEMBER_TMPFS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LinuxParameters$tmpfs", "com.amazonaws.ecs", "LinuxParameters"),
  122    122   
    ::aws_smithy_schema::ShapeType::List,
  123    123   
    "tmpfs",
  124    124   
    4,
  125    125   
);
  126    126   
static LINUXPARAMETERS_MEMBER_MAX_SWAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LinuxParameters$maxSwap", "com.amazonaws.ecs", "LinuxParameters"),
  128    128   
    ::aws_smithy_schema::ShapeType::Integer,
  129         -
    "max_swap",
         129  +
    "maxSwap",
  130    130   
    5,
  131    131   
);
  132    132   
static LINUXPARAMETERS_MEMBER_SWAPPINESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LinuxParameters$swappiness", "com.amazonaws.ecs", "LinuxParameters"),
  134    134   
    ::aws_smithy_schema::ShapeType::Integer,
  135    135   
    "swappiness",
  136    136   
    6,
  137    137   
);
  138    138   
static LINUXPARAMETERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  139    139   
    LINUXPARAMETERS_SCHEMA_ID,
@@ -173,173 +294,299 @@
  193    193   
            ser.write_integer(&LINUXPARAMETERS_MEMBER_MAX_SWAP, *val)?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.swappiness {
  196    196   
            ser.write_integer(&LINUXPARAMETERS_MEMBER_SWAPPINESS, *val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl LinuxParameters {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&LINUXPARAMETERS_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&LINUXPARAMETERS_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.capabilities = Some(crate::types::KernelCapabilities::deserialize(deser)?);
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.devices = Some({
  222         -
                        let container = if let Some(cap) = deser.container_size() {
  223         -
                            Vec::with_capacity(cap)
  224         -
                        } else {
  225         -
                            Vec::new()
  226         -
                        };
  227         -
                        deser.read_list(member, container, |mut list, deser| {
  228         -
                            list.push(crate::types::Device::deserialize(deser)?);
  229         -
                            Ok(list)
  230         -
                        })?
         222  +
                        let mut container = Vec::new();
         223  +
                        deser.read_list(member, &mut |deser| {
         224  +
                            container.push(crate::types::Device::deserialize(deser)?);
         225  +
                            Ok(())
         226  +
                        })?;
         227  +
                        container
  231    228   
                    });
  232    229   
                }
  233    230   
                Some(2) => {
  234    231   
                    builder.init_process_enabled = Some(deser.read_boolean(member)?);
  235    232   
                }
  236    233   
                Some(3) => {
  237    234   
                    builder.shared_memory_size = Some(deser.read_integer(member)?);
  238    235   
                }
  239    236   
                Some(4) => {
  240    237   
                    builder.tmpfs = Some({
  241         -
                        let container = if let Some(cap) = deser.container_size() {
  242         -
                            Vec::with_capacity(cap)
  243         -
                        } else {
  244         -
                            Vec::new()
  245         -
                        };
  246         -
                        deser.read_list(member, container, |mut list, deser| {
  247         -
                            list.push(crate::types::Tmpfs::deserialize(deser)?);
  248         -
                            Ok(list)
  249         -
                        })?
         238  +
                        let mut container = Vec::new();
         239  +
                        deser.read_list(member, &mut |deser| {
         240  +
                            container.push(crate::types::Tmpfs::deserialize(deser)?);
         241  +
                            Ok(())
         242  +
                        })?;
         243  +
                        container
  250    244   
                    });
  251    245   
                }
  252    246   
                Some(5) => {
  253    247   
                    builder.max_swap = Some(deser.read_integer(member)?);
  254    248   
                }
  255    249   
                Some(6) => {
  256    250   
                    builder.swappiness = Some(deser.read_integer(member)?);
  257    251   
                }
  258    252   
                _ => {}
  259    253   
            }
  260    254   
            Ok(())
  261    255   
        })?;
  262    256   
        Ok(builder.build())
  263    257   
    }
  264    258   
}
         259  +
impl LinuxParameters {
         260  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         261  +
    pub fn deserialize_with_response(
         262  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         263  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         264  +
        _status: u16,
         265  +
        _body: &[u8],
         266  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         267  +
        Self::deserialize(deserializer)
         268  +
    }
         269  +
}
  265    270   
impl LinuxParameters {
  266    271   
    /// Creates a new builder-style object to manufacture [`LinuxParameters`](crate::types::LinuxParameters).
  267    272   
    pub fn builder() -> crate::types::builders::LinuxParametersBuilder {
  268    273   
        crate::types::builders::LinuxParametersBuilder::default()
  269    274   
    }
  270    275   
}
  271    276   
  272    277   
/// A builder for [`LinuxParameters`](crate::types::LinuxParameters).
  273    278   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  274    279   
#[non_exhaustive]

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

@@ -32,32 +199,210 @@
   52     52   
    /// <p>The advanced settings for the load balancer used in blue/green deployments. Specify the alternate target group, listener rules, and IAM role required for traffic shifting during blue/green deployments.</p>
   53     53   
    pub fn advanced_configuration(&self) -> ::std::option::Option<&crate::types::AdvancedConfiguration> {
   54     54   
        self.advanced_configuration.as_ref()
   55     55   
    }
   56     56   
}
   57     57   
static LOADBALANCER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LoadBalancer", "com.amazonaws.ecs", "LoadBalancer");
   59     59   
static LOADBALANCER_MEMBER_TARGET_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LoadBalancer$targetGroupArn", "com.amazonaws.ecs", "LoadBalancer"),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "target_group_arn",
          62  +
    "targetGroupArn",
   63     63   
    0,
   64     64   
);
   65     65   
static LOADBALANCER_MEMBER_LOAD_BALANCER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LoadBalancer$loadBalancerName", "com.amazonaws.ecs", "LoadBalancer"),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "load_balancer_name",
          68  +
    "loadBalancerName",
   69     69   
    1,
   70     70   
);
   71     71   
static LOADBALANCER_MEMBER_CONTAINER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LoadBalancer$containerName", "com.amazonaws.ecs", "LoadBalancer"),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "container_name",
          74  +
    "containerName",
   75     75   
    2,
   76     76   
);
   77     77   
static LOADBALANCER_MEMBER_CONTAINER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LoadBalancer$containerPort", "com.amazonaws.ecs", "LoadBalancer"),
   79     79   
    ::aws_smithy_schema::ShapeType::Integer,
   80         -
    "container_port",
          80  +
    "containerPort",
   81     81   
    3,
   82     82   
);
   83     83   
static LOADBALANCER_MEMBER_ADVANCED_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ecs#LoadBalancer$advancedConfiguration",
   86     86   
        "com.amazonaws.ecs",
   87     87   
        "LoadBalancer",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::Structure,
   90         -
    "advanced_configuration",
          90  +
    "advancedConfiguration",
   91     91   
    4,
   92     92   
);
   93     93   
static LOADBALANCER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   94     94   
    LOADBALANCER_SCHEMA_ID,
   95     95   
    ::aws_smithy_schema::ShapeType::Structure,
   96     96   
    &[
   97     97   
        &LOADBALANCER_MEMBER_TARGET_GROUP_ARN,
   98     98   
        &LOADBALANCER_MEMBER_LOAD_BALANCER_NAME,
   99     99   
        &LOADBALANCER_MEMBER_CONTAINER_NAME,
  100    100   
        &LOADBALANCER_MEMBER_CONTAINER_PORT,
  101    101   
        &LOADBALANCER_MEMBER_ADVANCED_CONFIGURATION,
  102    102   
    ],
  103    103   
);
  104    104   
impl LoadBalancer {
  105    105   
    /// The schema for this shape.
  106    106   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOADBALANCER_SCHEMA;
  107    107   
}
  108    108   
impl ::aws_smithy_schema::serde::SerializableStruct for LoadBalancer {
  109    109   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  110    110   
    fn serialize_members(
  111    111   
        &self,
  112    112   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  113    113   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  114    114   
        if let Some(ref val) = self.target_group_arn {
  115    115   
            ser.write_string(&LOADBALANCER_MEMBER_TARGET_GROUP_ARN, val)?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.load_balancer_name {
  118    118   
            ser.write_string(&LOADBALANCER_MEMBER_LOAD_BALANCER_NAME, val)?;
  119    119   
        }
  120    120   
        if let Some(ref val) = self.container_name {
  121    121   
            ser.write_string(&LOADBALANCER_MEMBER_CONTAINER_NAME, val)?;
  122    122   
        }
  123    123   
        if let Some(ref val) = self.container_port {
  124    124   
            ser.write_integer(&LOADBALANCER_MEMBER_CONTAINER_PORT, *val)?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.advanced_configuration {
  127    127   
            ser.write_struct(&LOADBALANCER_MEMBER_ADVANCED_CONFIGURATION, val)?;
  128    128   
        }
  129    129   
        Ok(())
  130    130   
    }
  131    131   
}
  132    132   
impl LoadBalancer {
  133    133   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  134         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  135         -
        deserializer: &mut D,
         134  +
    pub fn deserialize(
         135  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  136    136   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  137    137   
        #[allow(unused_variables, unused_mut)]
  138    138   
        let mut builder = Self::builder();
  139    139   
        #[allow(
  140    140   
            unused_variables,
  141    141   
            unreachable_code,
  142    142   
            clippy::single_match,
  143    143   
            clippy::match_single_binding,
  144    144   
            clippy::diverging_sub_expression
  145    145   
        )]
  146         -
        deserializer.read_struct(&LOADBALANCER_SCHEMA, (), |_, member, deser| {
         146  +
        deserializer.read_struct(&LOADBALANCER_SCHEMA, &mut |member, deser| {
  147    147   
            match member.member_index() {
  148    148   
                Some(0) => {
  149    149   
                    builder.target_group_arn = Some(deser.read_string(member)?);
  150    150   
                }
  151    151   
                Some(1) => {
  152    152   
                    builder.load_balancer_name = Some(deser.read_string(member)?);
  153    153   
                }
  154    154   
                Some(2) => {
  155    155   
                    builder.container_name = Some(deser.read_string(member)?);
  156    156   
                }
  157    157   
                Some(3) => {
  158    158   
                    builder.container_port = Some(deser.read_integer(member)?);
  159    159   
                }
  160    160   
                Some(4) => {
  161    161   
                    builder.advanced_configuration = Some(crate::types::AdvancedConfiguration::deserialize(deser)?);
  162    162   
                }
  163    163   
                _ => {}
  164    164   
            }
  165    165   
            Ok(())
  166    166   
        })?;
  167    167   
        Ok(builder.build())
  168    168   
    }
  169    169   
}
         170  +
impl LoadBalancer {
         171  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         172  +
    pub fn deserialize_with_response(
         173  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         174  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         175  +
        _status: u16,
         176  +
        _body: &[u8],
         177  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         178  +
        Self::deserialize(deserializer)
         179  +
    }
         180  +
}
  170    181   
impl LoadBalancer {
  171    182   
    /// Creates a new builder-style object to manufacture [`LoadBalancer`](crate::types::LoadBalancer).
  172    183   
    pub fn builder() -> crate::types::builders::LoadBalancerBuilder {
  173    184   
        crate::types::builders::LoadBalancerBuilder::default()
  174    185   
    }
  175    186   
}
  176    187   
  177    188   
/// A builder for [`LoadBalancer`](crate::types::LoadBalancer).
  178    189   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  179    190   
#[non_exhaustive]

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

@@ -225,225 +406,404 @@
  245    245   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.secret_options.is_none()`.
  246    246   
    pub fn secret_options(&self) -> &[crate::types::Secret] {
  247    247   
        self.secret_options.as_deref().unwrap_or_default()
  248    248   
    }
  249    249   
}
  250    250   
static LOGCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  251    251   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LogConfiguration", "com.amazonaws.ecs", "LogConfiguration");
  252    252   
static LOGCONFIGURATION_MEMBER_LOG_DRIVER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  253    253   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LogConfiguration$logDriver", "com.amazonaws.ecs", "LogConfiguration"),
  254    254   
    ::aws_smithy_schema::ShapeType::String,
  255         -
    "log_driver",
         255  +
    "logDriver",
  256    256   
    0,
  257    257   
);
  258    258   
static LOGCONFIGURATION_MEMBER_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  259    259   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#LogConfiguration$options", "com.amazonaws.ecs", "LogConfiguration"),
  260    260   
    ::aws_smithy_schema::ShapeType::Map,
  261    261   
    "options",
  262    262   
    1,
  263    263   
);
  264    264   
static LOGCONFIGURATION_MEMBER_SECRET_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  265    265   
    ::aws_smithy_schema::ShapeId::from_static(
  266    266   
        "com.amazonaws.ecs#LogConfiguration$secretOptions",
  267    267   
        "com.amazonaws.ecs",
  268    268   
        "LogConfiguration",
  269    269   
    ),
  270    270   
    ::aws_smithy_schema::ShapeType::List,
  271         -
    "secret_options",
         271  +
    "secretOptions",
  272    272   
    2,
  273    273   
);
  274    274   
static LOGCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  275    275   
    LOGCONFIGURATION_SCHEMA_ID,
  276    276   
    ::aws_smithy_schema::ShapeType::Structure,
  277    277   
    &[
  278    278   
        &LOGCONFIGURATION_MEMBER_LOG_DRIVER,
  279    279   
        &LOGCONFIGURATION_MEMBER_OPTIONS,
  280    280   
        &LOGCONFIGURATION_MEMBER_SECRET_OPTIONS,
  281    281   
    ],
  282    282   
);
  283    283   
impl LogConfiguration {
  284    284   
    /// The schema for this shape.
  285    285   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOGCONFIGURATION_SCHEMA;
  286    286   
}
  287    287   
impl ::aws_smithy_schema::serde::SerializableStruct for LogConfiguration {
  288    288   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  289    289   
    fn serialize_members(
  290    290   
        &self,
  291    291   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  292    292   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  293    293   
        {
  294    294   
            let val = &self.log_driver;
  295    295   
            ser.write_string(&LOGCONFIGURATION_MEMBER_LOG_DRIVER, val.as_str())?;
  296    296   
        }
  297    297   
        if let Some(ref val) = self.options {
  298    298   
            ser.write_map(
  299    299   
                &LOGCONFIGURATION_MEMBER_OPTIONS,
  300    300   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  301    301   
                    for (key, value) in val {
  302    302   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  303    303   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  304    304   
                    }
  305    305   
                    Ok(())
  306    306   
                },
  307    307   
            )?;
  308    308   
        }
  309    309   
        if let Some(ref val) = self.secret_options {
  310    310   
            ser.write_list(
  311    311   
                &LOGCONFIGURATION_MEMBER_SECRET_OPTIONS,
  312    312   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  313    313   
                    for item in val {
  314    314   
                        ser.write_struct(crate::types::Secret::SCHEMA, item)?;
  315    315   
                    }
  316    316   
                    Ok(())
  317    317   
                },
  318    318   
            )?;
  319    319   
        }
  320    320   
        Ok(())
  321    321   
    }
  322    322   
}
  323    323   
impl LogConfiguration {
  324    324   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  325         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  326         -
        deserializer: &mut D,
         325  +
    pub fn deserialize(
         326  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  327    327   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  328    328   
        #[allow(unused_variables, unused_mut)]
  329    329   
        let mut builder = Self::builder();
  330    330   
        #[allow(
  331    331   
            unused_variables,
  332    332   
            unreachable_code,
  333    333   
            clippy::single_match,
  334    334   
            clippy::match_single_binding,
  335    335   
            clippy::diverging_sub_expression
  336    336   
        )]
  337         -
        deserializer.read_struct(&LOGCONFIGURATION_SCHEMA, (), |_, member, deser| {
         337  +
        deserializer.read_struct(&LOGCONFIGURATION_SCHEMA, &mut |member, deser| {
  338    338   
            match member.member_index() {
  339    339   
                Some(0) => {
  340    340   
                    builder.log_driver = Some(crate::types::LogDriver::from(deser.read_string(member)?.as_str()));
  341    341   
                }
  342    342   
                Some(1) => {
  343         -
                    builder.options = Some({
  344         -
                        let container = if let Some(cap) = deser.container_size() {
  345         -
                            std::collections::HashMap::with_capacity(cap)
  346         -
                        } else {
  347         -
                            std::collections::HashMap::new()
  348         -
                        };
  349         -
                        deser.read_map(member, container, |mut map, key, deser| {
  350         -
                            map.insert(key, deser.read_string(member)?);
  351         -
                            Ok(map)
  352         -
                        })?
  353         -
                    });
         343  +
                    builder.options = Some(deser.read_string_string_map(member)?);
  354    344   
                }
  355    345   
                Some(2) => {
  356    346   
                    builder.secret_options = Some({
  357         -
                        let container = if let Some(cap) = deser.container_size() {
  358         -
                            Vec::with_capacity(cap)
  359         -
                        } else {
  360         -
                            Vec::new()
  361         -
                        };
  362         -
                        deser.read_list(member, container, |mut list, deser| {
  363         -
                            list.push(crate::types::Secret::deserialize(deser)?);
  364         -
                            Ok(list)
  365         -
                        })?
         347  +
                        let mut container = Vec::new();
         348  +
                        deser.read_list(member, &mut |deser| {
         349  +
                            container.push(crate::types::Secret::deserialize(deser)?);
         350  +
                            Ok(())
         351  +
                        })?;
         352  +
                        container
  366    353   
                    });
  367    354   
                }
  368    355   
                _ => {}
  369    356   
            }
  370    357   
            Ok(())
  371    358   
        })?;
  372    359   
        builder
  373    360   
            .build()
  374    361   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  375    362   
    }
  376    363   
}
         364  +
impl LogConfiguration {
         365  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         366  +
    pub fn deserialize_with_response(
         367  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         368  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         369  +
        _status: u16,
         370  +
        _body: &[u8],
         371  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         372  +
        Self::deserialize(deserializer)
         373  +
    }
         374  +
}
  377    375   
impl LogConfiguration {
  378    376   
    /// Creates a new builder-style object to manufacture [`LogConfiguration`](crate::types::LogConfiguration).
  379    377   
    pub fn builder() -> crate::types::builders::LogConfigurationBuilder {
  380    378   
        crate::types::builders::LogConfigurationBuilder::default()
  381    379   
    }
  382    380   
}
  383    381   
  384    382   
/// A builder for [`LogConfiguration`](crate::types::LogConfiguration).
  385    383   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  386    384   
#[non_exhaustive]