AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

@@ -40,40 +130,130 @@
   60     60   
}
   61     61   
static SERVICECONNECTSERVICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceConnectService", "com.amazonaws.ecs", "ServiceConnectService");
   63     63   
static SERVICECONNECTSERVICE_MEMBER_PORT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.ecs#ServiceConnectService$portName",
   66     66   
        "com.amazonaws.ecs",
   67     67   
        "ServiceConnectService",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "port_name",
          70  +
    "portName",
   71     71   
    0,
   72     72   
);
   73     73   
static SERVICECONNECTSERVICE_MEMBER_DISCOVERY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ecs#ServiceConnectService$discoveryName",
   76     76   
        "com.amazonaws.ecs",
   77     77   
        "ServiceConnectService",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "discovery_name",
          80  +
    "discoveryName",
   81     81   
    1,
   82     82   
);
   83     83   
static SERVICECONNECTSERVICE_MEMBER_CLIENT_ALIASES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.ecs#ServiceConnectService$clientAliases",
   86     86   
        "com.amazonaws.ecs",
   87     87   
        "ServiceConnectService",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::List,
   90         -
    "client_aliases",
          90  +
    "clientAliases",
   91     91   
    2,
   92     92   
);
   93     93   
static SERVICECONNECTSERVICE_MEMBER_INGRESS_PORT_OVERRIDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.ecs#ServiceConnectService$ingressPortOverride",
   96     96   
        "com.amazonaws.ecs",
   97     97   
        "ServiceConnectService",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Integer,
  100         -
    "ingress_port_override",
         100  +
    "ingressPortOverride",
  101    101   
    3,
  102    102   
);
  103    103   
static SERVICECONNECTSERVICE_MEMBER_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ecs#ServiceConnectService$timeout",
  106    106   
        "com.amazonaws.ecs",
  107    107   
        "ServiceConnectService",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::Structure,
  110    110   
    "timeout",
@@ -147,147 +257,266 @@
  167    167   
            ser.write_struct(&SERVICECONNECTSERVICE_MEMBER_TIMEOUT, val)?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.tls {
  170    170   
            ser.write_struct(&SERVICECONNECTSERVICE_MEMBER_TLS, val)?;
  171    171   
        }
  172    172   
        Ok(())
  173    173   
    }
  174    174   
}
  175    175   
impl ServiceConnectService {
  176    176   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  177         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  178         -
        deserializer: &mut D,
         177  +
    pub fn deserialize(
         178  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  179    179   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  180    180   
        #[allow(unused_variables, unused_mut)]
  181    181   
        let mut builder = Self::builder();
  182    182   
        #[allow(
  183    183   
            unused_variables,
  184    184   
            unreachable_code,
  185    185   
            clippy::single_match,
  186    186   
            clippy::match_single_binding,
  187    187   
            clippy::diverging_sub_expression
  188    188   
        )]
  189         -
        deserializer.read_struct(&SERVICECONNECTSERVICE_SCHEMA, (), |_, member, deser| {
         189  +
        deserializer.read_struct(&SERVICECONNECTSERVICE_SCHEMA, &mut |member, deser| {
  190    190   
            match member.member_index() {
  191    191   
                Some(0) => {
  192    192   
                    builder.port_name = Some(deser.read_string(member)?);
  193    193   
                }
  194    194   
                Some(1) => {
  195    195   
                    builder.discovery_name = Some(deser.read_string(member)?);
  196    196   
                }
  197    197   
                Some(2) => {
  198    198   
                    builder.client_aliases = Some({
  199         -
                        let container = if let Some(cap) = deser.container_size() {
  200         -
                            Vec::with_capacity(cap)
  201         -
                        } else {
  202         -
                            Vec::new()
  203         -
                        };
  204         -
                        deser.read_list(member, container, |mut list, deser| {
  205         -
                            list.push(crate::types::ServiceConnectClientAlias::deserialize(deser)?);
  206         -
                            Ok(list)
  207         -
                        })?
         199  +
                        let mut container = Vec::new();
         200  +
                        deser.read_list(member, &mut |deser| {
         201  +
                            container.push(crate::types::ServiceConnectClientAlias::deserialize(deser)?);
         202  +
                            Ok(())
         203  +
                        })?;
         204  +
                        container
  208    205   
                    });
  209    206   
                }
  210    207   
                Some(3) => {
  211    208   
                    builder.ingress_port_override = Some(deser.read_integer(member)?);
  212    209   
                }
  213    210   
                Some(4) => {
  214    211   
                    builder.timeout = Some(crate::types::TimeoutConfiguration::deserialize(deser)?);
  215    212   
                }
  216    213   
                Some(5) => {
  217    214   
                    builder.tls = Some(crate::types::ServiceConnectTlsConfiguration::deserialize(deser)?);
  218    215   
                }
  219    216   
                _ => {}
  220    217   
            }
  221    218   
            Ok(())
  222    219   
        })?;
         220  +
        builder.port_name = builder.port_name.or(Some(String::new()));
  223    221   
        builder
  224    222   
            .build()
  225    223   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  226    224   
    }
  227    225   
}
         226  +
impl ServiceConnectService {
         227  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         228  +
    pub fn deserialize_with_response(
         229  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         230  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         231  +
        _status: u16,
         232  +
        _body: &[u8],
         233  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         234  +
        Self::deserialize(deserializer)
         235  +
    }
         236  +
}
  228    237   
impl ServiceConnectService {
  229    238   
    /// Creates a new builder-style object to manufacture [`ServiceConnectService`](crate::types::ServiceConnectService).
  230    239   
    pub fn builder() -> crate::types::builders::ServiceConnectServiceBuilder {
  231    240   
        crate::types::builders::ServiceConnectServiceBuilder::default()
  232    241   
    }
  233    242   
}
  234    243   
  235    244   
/// A builder for [`ServiceConnectService`](crate::types::ServiceConnectService).
  236    245   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  237    246   
#[non_exhaustive]

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

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

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

@@ -26,26 +111,123 @@
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        {
   48     48   
            let val = &self.exact;
   49     49   
            ser.write_string(&SERVICECONNECTTESTTRAFFICHEADERMATCHRULES_MEMBER_EXACT, val)?;
   50     50   
        }
   51     51   
        Ok(())
   52     52   
    }
   53     53   
}
   54     54   
impl ServiceConnectTestTrafficHeaderMatchRules {
   55     55   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   56         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   57         -
        deserializer: &mut D,
          56  +
    pub fn deserialize(
          57  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   58     58   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        #[allow(unused_variables, unused_mut)]
   60     60   
        let mut builder = Self::builder();
   61     61   
        #[allow(
   62     62   
            unused_variables,
   63     63   
            unreachable_code,
   64     64   
            clippy::single_match,
   65     65   
            clippy::match_single_binding,
   66     66   
            clippy::diverging_sub_expression
   67     67   
        )]
   68         -
        deserializer.read_struct(&SERVICECONNECTTESTTRAFFICHEADERMATCHRULES_SCHEMA, (), |_, member, deser| {
          68  +
        deserializer.read_struct(&SERVICECONNECTTESTTRAFFICHEADERMATCHRULES_SCHEMA, &mut |member, deser| {
   69     69   
            match member.member_index() {
   70     70   
                Some(0) => {
   71     71   
                    builder.exact = Some(deser.read_string(member)?);
   72     72   
                }
   73     73   
                _ => {}
   74     74   
            }
   75     75   
            Ok(())
   76     76   
        })?;
          77  +
        builder.exact = builder.exact.or(Some(String::new()));
   77     78   
        builder
   78     79   
            .build()
   79     80   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   80     81   
    }
   81     82   
}
          83  +
impl ServiceConnectTestTrafficHeaderMatchRules {
          84  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          85  +
    pub fn deserialize_with_response(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          87  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          88  +
        _status: u16,
          89  +
        _body: &[u8],
          90  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          91  +
        Self::deserialize(deserializer)
          92  +
    }
          93  +
}
   82     94   
impl ServiceConnectTestTrafficHeaderMatchRules {
   83     95   
    /// Creates a new builder-style object to manufacture [`ServiceConnectTestTrafficHeaderMatchRules`](crate::types::ServiceConnectTestTrafficHeaderMatchRules).
   84     96   
    pub fn builder() -> crate::types::builders::ServiceConnectTestTrafficHeaderMatchRulesBuilder {
   85     97   
        crate::types::builders::ServiceConnectTestTrafficHeaderMatchRulesBuilder::default()
   86     98   
    }
   87     99   
}
   88    100   
   89    101   
/// A builder for [`ServiceConnectTestTrafficHeaderMatchRules`](crate::types::ServiceConnectTestTrafficHeaderMatchRules).
   90    102   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   91    103   
#[non_exhaustive]

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

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

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

@@ -25,25 +108,119 @@
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.header {
   48     48   
            ser.write_struct(&SERVICECONNECTTESTTRAFFICRULES_MEMBER_HEADER, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl ServiceConnectTestTrafficRules {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&SERVICECONNECTTESTTRAFFICRULES_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&SERVICECONNECTTESTTRAFFICRULES_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.header = Some(crate::types::ServiceConnectTestTrafficHeaderRules::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl ServiceConnectTestTrafficRules {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl ServiceConnectTestTrafficRules {
   80     91   
    /// Creates a new builder-style object to manufacture [`ServiceConnectTestTrafficRules`](crate::types::ServiceConnectTestTrafficRules).
   81     92   
    pub fn builder() -> crate::types::builders::ServiceConnectTestTrafficRulesBuilder {
   82     93   
        crate::types::builders::ServiceConnectTestTrafficRulesBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`ServiceConnectTestTrafficRules`](crate::types::ServiceConnectTestTrafficRules).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

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

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

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

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

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

@@ -172,172 +346,346 @@
  192    192   
}
  193    193   
static SERVICEDEPLOYMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  194    194   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment", "com.amazonaws.ecs", "ServiceDeployment");
  195    195   
static SERVICEDEPLOYMENT_MEMBER_SERVICE_DEPLOYMENT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static(
  197    197   
        "com.amazonaws.ecs#ServiceDeployment$serviceDeploymentArn",
  198    198   
        "com.amazonaws.ecs",
  199    199   
        "ServiceDeployment",
  200    200   
    ),
  201    201   
    ::aws_smithy_schema::ShapeType::String,
  202         -
    "service_deployment_arn",
         202  +
    "serviceDeploymentArn",
  203    203   
    0,
  204    204   
);
  205    205   
static SERVICEDEPLOYMENT_MEMBER_SERVICE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  206    206   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$serviceArn", "com.amazonaws.ecs", "ServiceDeployment"),
  207    207   
    ::aws_smithy_schema::ShapeType::String,
  208         -
    "service_arn",
         208  +
    "serviceArn",
  209    209   
    1,
  210    210   
);
  211    211   
static SERVICEDEPLOYMENT_MEMBER_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$clusterArn", "com.amazonaws.ecs", "ServiceDeployment"),
  213    213   
    ::aws_smithy_schema::ShapeType::String,
  214         -
    "cluster_arn",
         214  +
    "clusterArn",
  215    215   
    2,
  216    216   
);
  217    217   
static SERVICEDEPLOYMENT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    218   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$createdAt", "com.amazonaws.ecs", "ServiceDeployment"),
  219    219   
    ::aws_smithy_schema::ShapeType::Timestamp,
  220         -
    "created_at",
         220  +
    "createdAt",
  221    221   
    3,
  222    222   
);
  223    223   
static SERVICEDEPLOYMENT_MEMBER_STARTED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  224    224   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$startedAt", "com.amazonaws.ecs", "ServiceDeployment"),
  225    225   
    ::aws_smithy_schema::ShapeType::Timestamp,
  226         -
    "started_at",
         226  +
    "startedAt",
  227    227   
    4,
  228    228   
);
  229    229   
static SERVICEDEPLOYMENT_MEMBER_FINISHED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  230    230   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$finishedAt", "com.amazonaws.ecs", "ServiceDeployment"),
  231    231   
    ::aws_smithy_schema::ShapeType::Timestamp,
  232         -
    "finished_at",
         232  +
    "finishedAt",
  233    233   
    5,
  234    234   
);
  235    235   
static SERVICEDEPLOYMENT_MEMBER_STOPPED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  236    236   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$stoppedAt", "com.amazonaws.ecs", "ServiceDeployment"),
  237    237   
    ::aws_smithy_schema::ShapeType::Timestamp,
  238         -
    "stopped_at",
         238  +
    "stoppedAt",
  239    239   
    6,
  240    240   
);
  241    241   
static SERVICEDEPLOYMENT_MEMBER_UPDATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  242    242   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$updatedAt", "com.amazonaws.ecs", "ServiceDeployment"),
  243    243   
    ::aws_smithy_schema::ShapeType::Timestamp,
  244         -
    "updated_at",
         244  +
    "updatedAt",
  245    245   
    7,
  246    246   
);
  247    247   
static SERVICEDEPLOYMENT_MEMBER_SOURCE_SERVICE_REVISIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  248    248   
    ::aws_smithy_schema::ShapeId::from_static(
  249    249   
        "com.amazonaws.ecs#ServiceDeployment$sourceServiceRevisions",
  250    250   
        "com.amazonaws.ecs",
  251    251   
        "ServiceDeployment",
  252    252   
    ),
  253    253   
    ::aws_smithy_schema::ShapeType::List,
  254         -
    "source_service_revisions",
         254  +
    "sourceServiceRevisions",
  255    255   
    8,
  256    256   
);
  257    257   
static SERVICEDEPLOYMENT_MEMBER_TARGET_SERVICE_REVISION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  258    258   
    ::aws_smithy_schema::ShapeId::from_static(
  259    259   
        "com.amazonaws.ecs#ServiceDeployment$targetServiceRevision",
  260    260   
        "com.amazonaws.ecs",
  261    261   
        "ServiceDeployment",
  262    262   
    ),
  263    263   
    ::aws_smithy_schema::ShapeType::Structure,
  264         -
    "target_service_revision",
         264  +
    "targetServiceRevision",
  265    265   
    9,
  266    266   
);
  267    267   
static SERVICEDEPLOYMENT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  268    268   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$status", "com.amazonaws.ecs", "ServiceDeployment"),
  269    269   
    ::aws_smithy_schema::ShapeType::String,
  270    270   
    "status",
  271    271   
    10,
  272    272   
);
  273    273   
static SERVICEDEPLOYMENT_MEMBER_STATUS_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  274    274   
    ::aws_smithy_schema::ShapeId::from_static(
  275    275   
        "com.amazonaws.ecs#ServiceDeployment$statusReason",
  276    276   
        "com.amazonaws.ecs",
  277    277   
        "ServiceDeployment",
  278    278   
    ),
  279    279   
    ::aws_smithy_schema::ShapeType::String,
  280         -
    "status_reason",
         280  +
    "statusReason",
  281    281   
    11,
  282    282   
);
  283    283   
static SERVICEDEPLOYMENT_MEMBER_LIFECYCLE_STAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  284    284   
    ::aws_smithy_schema::ShapeId::from_static(
  285    285   
        "com.amazonaws.ecs#ServiceDeployment$lifecycleStage",
  286    286   
        "com.amazonaws.ecs",
  287    287   
        "ServiceDeployment",
  288    288   
    ),
  289    289   
    ::aws_smithy_schema::ShapeType::String,
  290         -
    "lifecycle_stage",
         290  +
    "lifecycleStage",
  291    291   
    12,
  292    292   
);
  293    293   
static SERVICEDEPLOYMENT_MEMBER_DEPLOYMENT_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  294    294   
    ::aws_smithy_schema::ShapeId::from_static(
  295    295   
        "com.amazonaws.ecs#ServiceDeployment$deploymentConfiguration",
  296    296   
        "com.amazonaws.ecs",
  297    297   
        "ServiceDeployment",
  298    298   
    ),
  299    299   
    ::aws_smithy_schema::ShapeType::Structure,
  300         -
    "deployment_configuration",
         300  +
    "deploymentConfiguration",
  301    301   
    13,
  302    302   
);
  303    303   
static SERVICEDEPLOYMENT_MEMBER_ROLLBACK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  304    304   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$rollback", "com.amazonaws.ecs", "ServiceDeployment"),
  305    305   
    ::aws_smithy_schema::ShapeType::Structure,
  306    306   
    "rollback",
  307    307   
    14,
  308    308   
);
  309    309   
static SERVICEDEPLOYMENT_MEMBER_DEPLOYMENT_CIRCUIT_BREAKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  310    310   
    ::aws_smithy_schema::ShapeId::from_static(
  311    311   
        "com.amazonaws.ecs#ServiceDeployment$deploymentCircuitBreaker",
  312    312   
        "com.amazonaws.ecs",
  313    313   
        "ServiceDeployment",
  314    314   
    ),
  315    315   
    ::aws_smithy_schema::ShapeType::Structure,
  316         -
    "deployment_circuit_breaker",
         316  +
    "deploymentCircuitBreaker",
  317    317   
    15,
  318    318   
);
  319    319   
static SERVICEDEPLOYMENT_MEMBER_ALARMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  320    320   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeployment$alarms", "com.amazonaws.ecs", "ServiceDeployment"),
  321    321   
    ::aws_smithy_schema::ShapeType::Structure,
  322    322   
    "alarms",
  323    323   
    16,
  324    324   
);
  325    325   
static SERVICEDEPLOYMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  326    326   
    SERVICEDEPLOYMENT_SCHEMA_ID,
@@ -392,392 +533,541 @@
  412    412   
            ser.write_struct(&SERVICEDEPLOYMENT_MEMBER_DEPLOYMENT_CIRCUIT_BREAKER, val)?;
  413    413   
        }
  414    414   
        if let Some(ref val) = self.alarms {
  415    415   
            ser.write_struct(&SERVICEDEPLOYMENT_MEMBER_ALARMS, val)?;
  416    416   
        }
  417    417   
        Ok(())
  418    418   
    }
  419    419   
}
  420    420   
impl ServiceDeployment {
  421    421   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  422         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  423         -
        deserializer: &mut D,
         422  +
    pub fn deserialize(
         423  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  424    424   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  425    425   
        #[allow(unused_variables, unused_mut)]
  426    426   
        let mut builder = Self::builder();
  427    427   
        #[allow(
  428    428   
            unused_variables,
  429    429   
            unreachable_code,
  430    430   
            clippy::single_match,
  431    431   
            clippy::match_single_binding,
  432    432   
            clippy::diverging_sub_expression
  433    433   
        )]
  434         -
        deserializer.read_struct(&SERVICEDEPLOYMENT_SCHEMA, (), |_, member, deser| {
         434  +
        deserializer.read_struct(&SERVICEDEPLOYMENT_SCHEMA, &mut |member, deser| {
  435    435   
            match member.member_index() {
  436    436   
                Some(0) => {
  437    437   
                    builder.service_deployment_arn = Some(deser.read_string(member)?);
  438    438   
                }
  439    439   
                Some(1) => {
  440    440   
                    builder.service_arn = Some(deser.read_string(member)?);
  441    441   
                }
  442    442   
                Some(2) => {
  443    443   
                    builder.cluster_arn = Some(deser.read_string(member)?);
  444    444   
                }
  445    445   
                Some(3) => {
  446    446   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  447    447   
                }
  448    448   
                Some(4) => {
  449    449   
                    builder.started_at = Some(deser.read_timestamp(member)?);
  450    450   
                }
  451    451   
                Some(5) => {
  452    452   
                    builder.finished_at = Some(deser.read_timestamp(member)?);
  453    453   
                }
  454    454   
                Some(6) => {
  455    455   
                    builder.stopped_at = Some(deser.read_timestamp(member)?);
  456    456   
                }
  457    457   
                Some(7) => {
  458    458   
                    builder.updated_at = Some(deser.read_timestamp(member)?);
  459    459   
                }
  460    460   
                Some(8) => {
  461    461   
                    builder.source_service_revisions = Some({
  462         -
                        let container = if let Some(cap) = deser.container_size() {
  463         -
                            Vec::with_capacity(cap)
  464         -
                        } else {
  465         -
                            Vec::new()
  466         -
                        };
  467         -
                        deser.read_list(member, container, |mut list, deser| {
  468         -
                            list.push(crate::types::ServiceRevisionSummary::deserialize(deser)?);
  469         -
                            Ok(list)
  470         -
                        })?
         462  +
                        let mut container = Vec::new();
         463  +
                        deser.read_list(member, &mut |deser| {
         464  +
                            container.push(crate::types::ServiceRevisionSummary::deserialize(deser)?);
         465  +
                            Ok(())
         466  +
                        })?;
         467  +
                        container
  471    468   
                    });
  472    469   
                }
  473    470   
                Some(9) => {
  474    471   
                    builder.target_service_revision = Some(crate::types::ServiceRevisionSummary::deserialize(deser)?);
  475    472   
                }
  476    473   
                Some(10) => {
  477    474   
                    builder.status = Some(crate::types::ServiceDeploymentStatus::from(deser.read_string(member)?.as_str()));
  478    475   
                }
  479    476   
                Some(11) => {
  480    477   
                    builder.status_reason = Some(deser.read_string(member)?);
  481    478   
                }
  482    479   
                Some(12) => {
  483    480   
                    builder.lifecycle_stage = Some(crate::types::ServiceDeploymentLifecycleStage::from(deser.read_string(member)?.as_str()));
  484    481   
                }
  485    482   
                Some(13) => {
  486    483   
                    builder.deployment_configuration = Some(crate::types::DeploymentConfiguration::deserialize(deser)?);
  487    484   
                }
  488    485   
                Some(14) => {
  489    486   
                    builder.rollback = Some(crate::types::Rollback::deserialize(deser)?);
  490    487   
                }
  491    488   
                Some(15) => {
  492    489   
                    builder.deployment_circuit_breaker = Some(crate::types::ServiceDeploymentCircuitBreaker::deserialize(deser)?);
  493    490   
                }
  494    491   
                Some(16) => {
  495    492   
                    builder.alarms = Some(crate::types::ServiceDeploymentAlarms::deserialize(deser)?);
  496    493   
                }
  497    494   
                _ => {}
  498    495   
            }
  499    496   
            Ok(())
  500    497   
        })?;
  501    498   
        Ok(builder.build())
  502    499   
    }
  503    500   
}
         501  +
impl ServiceDeployment {
         502  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         503  +
    pub fn deserialize_with_response(
         504  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         505  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         506  +
        _status: u16,
         507  +
        _body: &[u8],
         508  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         509  +
        Self::deserialize(deserializer)
         510  +
    }
         511  +
}
  504    512   
impl ServiceDeployment {
  505    513   
    /// Creates a new builder-style object to manufacture [`ServiceDeployment`](crate::types::ServiceDeployment).
  506    514   
    pub fn builder() -> crate::types::builders::ServiceDeploymentBuilder {
  507    515   
        crate::types::builders::ServiceDeploymentBuilder::default()
  508    516   
    }
  509    517   
}
  510    518   
  511    519   
/// A builder for [`ServiceDeployment`](crate::types::ServiceDeployment).
  512    520   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  513    521   
#[non_exhaustive]

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

@@ -25,25 +198,189 @@
   45     45   
    "status",
   46     46   
    0,
   47     47   
);
   48     48   
static SERVICEDEPLOYMENTALARMS_MEMBER_ALARM_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.ecs#ServiceDeploymentAlarms$alarmNames",
   51     51   
        "com.amazonaws.ecs",
   52     52   
        "ServiceDeploymentAlarms",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::List,
   55         -
    "alarm_names",
          55  +
    "alarmNames",
   56     56   
    1,
   57     57   
);
   58     58   
static SERVICEDEPLOYMENTALARMS_MEMBER_TRIGGERED_ALARM_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.ecs#ServiceDeploymentAlarms$triggeredAlarmNames",
   61     61   
        "com.amazonaws.ecs",
   62     62   
        "ServiceDeploymentAlarms",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::List,
   65         -
    "triggered_alarm_names",
          65  +
    "triggeredAlarmNames",
   66     66   
    2,
   67     67   
);
   68     68   
static SERVICEDEPLOYMENTALARMS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    SERVICEDEPLOYMENTALARMS_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &SERVICEDEPLOYMENTALARMS_MEMBER_STATUS,
   73     73   
        &SERVICEDEPLOYMENTALARMS_MEMBER_ALARM_NAMES,
   74     74   
        &SERVICEDEPLOYMENTALARMS_MEMBER_TRIGGERED_ALARM_NAMES,
   75     75   
    ],
   76     76   
);
   77     77   
impl ServiceDeploymentAlarms {
   78     78   
    /// The schema for this shape.
   79     79   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEDEPLOYMENTALARMS_SCHEMA;
   80     80   
}
   81     81   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceDeploymentAlarms {
   82     82   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   83     83   
    fn serialize_members(
   84     84   
        &self,
   85     85   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   86     86   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   87     87   
        if let Some(ref val) = self.status {
   88     88   
            ser.write_string(&SERVICEDEPLOYMENTALARMS_MEMBER_STATUS, val.as_str())?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.alarm_names {
   91     91   
            ser.write_list(
   92     92   
                &SERVICEDEPLOYMENTALARMS_MEMBER_ALARM_NAMES,
   93     93   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   94     94   
                    for item in val {
   95     95   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   96     96   
                    }
   97     97   
                    Ok(())
   98     98   
                },
   99     99   
            )?;
  100    100   
        }
  101    101   
        if let Some(ref val) = self.triggered_alarm_names {
  102    102   
            ser.write_list(
  103    103   
                &SERVICEDEPLOYMENTALARMS_MEMBER_TRIGGERED_ALARM_NAMES,
  104    104   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  105    105   
                    for item in val {
  106    106   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  107    107   
                    }
  108    108   
                    Ok(())
  109    109   
                },
  110    110   
            )?;
  111    111   
        }
  112    112   
        Ok(())
  113    113   
    }
  114    114   
}
  115    115   
impl ServiceDeploymentAlarms {
  116    116   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  117         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  118         -
        deserializer: &mut D,
         117  +
    pub fn deserialize(
         118  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  119    119   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  120    120   
        #[allow(unused_variables, unused_mut)]
  121    121   
        let mut builder = Self::builder();
  122    122   
        #[allow(
  123    123   
            unused_variables,
  124    124   
            unreachable_code,
  125    125   
            clippy::single_match,
  126    126   
            clippy::match_single_binding,
  127    127   
            clippy::diverging_sub_expression
  128    128   
        )]
  129         -
        deserializer.read_struct(&SERVICEDEPLOYMENTALARMS_SCHEMA, (), |_, member, deser| {
         129  +
        deserializer.read_struct(&SERVICEDEPLOYMENTALARMS_SCHEMA, &mut |member, deser| {
  130    130   
            match member.member_index() {
  131    131   
                Some(0) => {
  132    132   
                    builder.status = Some(crate::types::ServiceDeploymentRollbackMonitorsStatus::from(
  133    133   
                        deser.read_string(member)?.as_str(),
  134    134   
                    ));
  135    135   
                }
  136    136   
                Some(1) => {
  137         -
                    builder.alarm_names = Some({
  138         -
                        let container = if let Some(cap) = deser.container_size() {
  139         -
                            Vec::with_capacity(cap)
  140         -
                        } else {
  141         -
                            Vec::new()
  142         -
                        };
  143         -
                        deser.read_list(member, container, |mut list, deser| {
  144         -
                            list.push(deser.read_string(member)?);
  145         -
                            Ok(list)
  146         -
                        })?
  147         -
                    });
         137  +
                    builder.alarm_names = Some(deser.read_string_list(member)?);
  148    138   
                }
  149    139   
                Some(2) => {
  150         -
                    builder.triggered_alarm_names = Some({
  151         -
                        let container = if let Some(cap) = deser.container_size() {
  152         -
                            Vec::with_capacity(cap)
  153         -
                        } else {
  154         -
                            Vec::new()
  155         -
                        };
  156         -
                        deser.read_list(member, container, |mut list, deser| {
  157         -
                            list.push(deser.read_string(member)?);
  158         -
                            Ok(list)
  159         -
                        })?
  160         -
                    });
         140  +
                    builder.triggered_alarm_names = Some(deser.read_string_list(member)?);
  161    141   
                }
  162    142   
                _ => {}
  163    143   
            }
  164    144   
            Ok(())
  165    145   
        })?;
  166    146   
        Ok(builder.build())
  167    147   
    }
  168    148   
}
         149  +
impl ServiceDeploymentAlarms {
         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  +
}
  169    160   
impl ServiceDeploymentAlarms {
  170    161   
    /// Creates a new builder-style object to manufacture [`ServiceDeploymentAlarms`](crate::types::ServiceDeploymentAlarms).
  171    162   
    pub fn builder() -> crate::types::builders::ServiceDeploymentAlarmsBuilder {
  172    163   
        crate::types::builders::ServiceDeploymentAlarmsBuilder::default()
  173    164   
    }
  174    165   
}
  175    166   
  176    167   
/// A builder for [`ServiceDeploymentAlarms`](crate::types::ServiceDeploymentAlarms).
  177    168   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  178    169   
#[non_exhaustive]

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

@@ -44,44 +291,302 @@
   64     64   
}
   65     65   
static SERVICEDEPLOYMENTBRIEF_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceDeploymentBrief", "com.amazonaws.ecs", "ServiceDeploymentBrief");
   67     67   
static SERVICEDEPLOYMENTBRIEF_MEMBER_SERVICE_DEPLOYMENT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.ecs#ServiceDeploymentBrief$serviceDeploymentArn",
   70     70   
        "com.amazonaws.ecs",
   71     71   
        "ServiceDeploymentBrief",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "service_deployment_arn",
          74  +
    "serviceDeploymentArn",
   75     75   
    0,
   76     76   
);
   77     77   
static SERVICEDEPLOYMENTBRIEF_MEMBER_SERVICE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ecs#ServiceDeploymentBrief$serviceArn",
   80     80   
        "com.amazonaws.ecs",
   81     81   
        "ServiceDeploymentBrief",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "service_arn",
          84  +
    "serviceArn",
   85     85   
    1,
   86     86   
);
   87     87   
static SERVICEDEPLOYMENTBRIEF_MEMBER_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.ecs#ServiceDeploymentBrief$clusterArn",
   90     90   
        "com.amazonaws.ecs",
   91     91   
        "ServiceDeploymentBrief",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "cluster_arn",
          94  +
    "clusterArn",
   95     95   
    2,
   96     96   
);
   97     97   
static SERVICEDEPLOYMENTBRIEF_MEMBER_STARTED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.ecs#ServiceDeploymentBrief$startedAt",
  100    100   
        "com.amazonaws.ecs",
  101    101   
        "ServiceDeploymentBrief",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Timestamp,
  104         -
    "started_at",
         104  +
    "startedAt",
  105    105   
    3,
  106    106   
);
  107    107   
static SERVICEDEPLOYMENTBRIEF_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.ecs#ServiceDeploymentBrief$createdAt",
  110    110   
        "com.amazonaws.ecs",
  111    111   
        "ServiceDeploymentBrief",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Timestamp,
  114         -
    "created_at",
         114  +
    "createdAt",
  115    115   
    4,
  116    116   
);
  117    117   
static SERVICEDEPLOYMENTBRIEF_MEMBER_FINISHED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ecs#ServiceDeploymentBrief$finishedAt",
  120    120   
        "com.amazonaws.ecs",
  121    121   
        "ServiceDeploymentBrief",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::Timestamp,
  124         -
    "finished_at",
         124  +
    "finishedAt",
  125    125   
    5,
  126    126   
);
  127    127   
static SERVICEDEPLOYMENTBRIEF_MEMBER_TARGET_SERVICE_REVISION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.ecs#ServiceDeploymentBrief$targetServiceRevisionArn",
  130    130   
        "com.amazonaws.ecs",
  131    131   
        "ServiceDeploymentBrief",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "target_service_revision_arn",
         134  +
    "targetServiceRevisionArn",
  135    135   
    6,
  136    136   
);
  137    137   
static SERVICEDEPLOYMENTBRIEF_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.ecs#ServiceDeploymentBrief$status",
  140    140   
        "com.amazonaws.ecs",
  141    141   
        "ServiceDeploymentBrief",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::String,
  144    144   
    "status",
  145    145   
    7,
  146    146   
);
  147    147   
static SERVICEDEPLOYMENTBRIEF_MEMBER_STATUS_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.ecs#ServiceDeploymentBrief$statusReason",
  150    150   
        "com.amazonaws.ecs",
  151    151   
        "ServiceDeploymentBrief",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::String,
  154         -
    "status_reason",
         154  +
    "statusReason",
  155    155   
    8,
  156    156   
);
  157    157   
static SERVICEDEPLOYMENTBRIEF_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  158    158   
    SERVICEDEPLOYMENTBRIEF_SCHEMA_ID,
  159    159   
    ::aws_smithy_schema::ShapeType::Structure,
  160    160   
    &[
  161    161   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_SERVICE_DEPLOYMENT_ARN,
  162    162   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_SERVICE_ARN,
  163    163   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_CLUSTER_ARN,
  164    164   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_STARTED_AT,
  165    165   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_CREATED_AT,
  166    166   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_FINISHED_AT,
  167    167   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_TARGET_SERVICE_REVISION_ARN,
  168    168   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_STATUS,
  169    169   
        &SERVICEDEPLOYMENTBRIEF_MEMBER_STATUS_REASON,
  170    170   
    ],
  171    171   
);
  172    172   
impl ServiceDeploymentBrief {
  173    173   
    /// The schema for this shape.
  174    174   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEDEPLOYMENTBRIEF_SCHEMA;
  175    175   
}
  176    176   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceDeploymentBrief {
  177    177   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  178    178   
    fn serialize_members(
  179    179   
        &self,
  180    180   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  181    181   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  182    182   
        if let Some(ref val) = self.service_deployment_arn {
  183    183   
            ser.write_string(&SERVICEDEPLOYMENTBRIEF_MEMBER_SERVICE_DEPLOYMENT_ARN, val)?;
  184    184   
        }
  185    185   
        if let Some(ref val) = self.service_arn {
  186    186   
            ser.write_string(&SERVICEDEPLOYMENTBRIEF_MEMBER_SERVICE_ARN, val)?;
  187    187   
        }
  188    188   
        if let Some(ref val) = self.cluster_arn {
  189    189   
            ser.write_string(&SERVICEDEPLOYMENTBRIEF_MEMBER_CLUSTER_ARN, val)?;
  190    190   
        }
  191    191   
        if let Some(ref val) = self.started_at {
  192    192   
            ser.write_timestamp(&SERVICEDEPLOYMENTBRIEF_MEMBER_STARTED_AT, val)?;
  193    193   
        }
  194    194   
        if let Some(ref val) = self.created_at {
  195    195   
            ser.write_timestamp(&SERVICEDEPLOYMENTBRIEF_MEMBER_CREATED_AT, val)?;
  196    196   
        }
  197    197   
        if let Some(ref val) = self.finished_at {
  198    198   
            ser.write_timestamp(&SERVICEDEPLOYMENTBRIEF_MEMBER_FINISHED_AT, val)?;
  199    199   
        }
  200    200   
        if let Some(ref val) = self.target_service_revision_arn {
  201    201   
            ser.write_string(&SERVICEDEPLOYMENTBRIEF_MEMBER_TARGET_SERVICE_REVISION_ARN, val)?;
  202    202   
        }
  203    203   
        if let Some(ref val) = self.status {
  204    204   
            ser.write_string(&SERVICEDEPLOYMENTBRIEF_MEMBER_STATUS, val.as_str())?;
  205    205   
        }
  206    206   
        if let Some(ref val) = self.status_reason {
  207    207   
            ser.write_string(&SERVICEDEPLOYMENTBRIEF_MEMBER_STATUS_REASON, val)?;
  208    208   
        }
  209    209   
        Ok(())
  210    210   
    }
  211    211   
}
  212    212   
impl ServiceDeploymentBrief {
  213    213   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  214         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  215         -
        deserializer: &mut D,
         214  +
    pub fn deserialize(
         215  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  216    216   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  217    217   
        #[allow(unused_variables, unused_mut)]
  218    218   
        let mut builder = Self::builder();
  219    219   
        #[allow(
  220    220   
            unused_variables,
  221    221   
            unreachable_code,
  222    222   
            clippy::single_match,
  223    223   
            clippy::match_single_binding,
  224    224   
            clippy::diverging_sub_expression
  225    225   
        )]
  226         -
        deserializer.read_struct(&SERVICEDEPLOYMENTBRIEF_SCHEMA, (), |_, member, deser| {
         226  +
        deserializer.read_struct(&SERVICEDEPLOYMENTBRIEF_SCHEMA, &mut |member, deser| {
  227    227   
            match member.member_index() {
  228    228   
                Some(0) => {
  229    229   
                    builder.service_deployment_arn = Some(deser.read_string(member)?);
  230    230   
                }
  231    231   
                Some(1) => {
  232    232   
                    builder.service_arn = Some(deser.read_string(member)?);
  233    233   
                }
  234    234   
                Some(2) => {
  235    235   
                    builder.cluster_arn = Some(deser.read_string(member)?);
  236    236   
                }
  237    237   
                Some(3) => {
  238    238   
                    builder.started_at = Some(deser.read_timestamp(member)?);
  239    239   
                }
  240    240   
                Some(4) => {
  241    241   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  242    242   
                }
  243    243   
                Some(5) => {
  244    244   
                    builder.finished_at = Some(deser.read_timestamp(member)?);
  245    245   
                }
  246    246   
                Some(6) => {
  247    247   
                    builder.target_service_revision_arn = Some(deser.read_string(member)?);
  248    248   
                }
  249    249   
                Some(7) => {
  250    250   
                    builder.status = Some(crate::types::ServiceDeploymentStatus::from(deser.read_string(member)?.as_str()));
  251    251   
                }
  252    252   
                Some(8) => {
  253    253   
                    builder.status_reason = Some(deser.read_string(member)?);
  254    254   
                }
  255    255   
                _ => {}
  256    256   
            }
  257    257   
            Ok(())
  258    258   
        })?;
  259    259   
        Ok(builder.build())
  260    260   
    }
  261    261   
}
         262  +
impl ServiceDeploymentBrief {
         263  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         264  +
    pub fn deserialize_with_response(
         265  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         266  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         267  +
        _status: u16,
         268  +
        _body: &[u8],
         269  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         270  +
        Self::deserialize(deserializer)
         271  +
    }
         272  +
}
  262    273   
impl ServiceDeploymentBrief {
  263    274   
    /// Creates a new builder-style object to manufacture [`ServiceDeploymentBrief`](crate::types::ServiceDeploymentBrief).
  264    275   
    pub fn builder() -> crate::types::builders::ServiceDeploymentBriefBuilder {
  265    276   
        crate::types::builders::ServiceDeploymentBriefBuilder::default()
  266    277   
    }
  267    278   
}
  268    279   
  269    280   
/// A builder for [`ServiceDeploymentBrief`](crate::types::ServiceDeploymentBrief).
  270    281   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  271    282   
#[non_exhaustive]

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

@@ -25,25 +164,175 @@
   45     45   
    "status",
   46     46   
    0,
   47     47   
);
   48     48   
static SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_FAILURE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.ecs#ServiceDeploymentCircuitBreaker$failureCount",
   51     51   
        "com.amazonaws.ecs",
   52     52   
        "ServiceDeploymentCircuitBreaker",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::Integer,
   55         -
    "failure_count",
          55  +
    "failureCount",
   56     56   
    1,
   57     57   
);
   58     58   
static SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.ecs#ServiceDeploymentCircuitBreaker$threshold",
   61     61   
        "com.amazonaws.ecs",
   62     62   
        "ServiceDeploymentCircuitBreaker",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::Integer,
   65     65   
    "threshold",
   66     66   
    2,
   67     67   
);
   68     68   
static SERVICEDEPLOYMENTCIRCUITBREAKER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    SERVICEDEPLOYMENTCIRCUITBREAKER_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_STATUS,
   73     73   
        &SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_FAILURE_COUNT,
   74     74   
        &SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_THRESHOLD,
   75     75   
    ],
   76     76   
);
   77     77   
impl ServiceDeploymentCircuitBreaker {
   78     78   
    /// The schema for this shape.
   79     79   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEDEPLOYMENTCIRCUITBREAKER_SCHEMA;
   80     80   
}
   81     81   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceDeploymentCircuitBreaker {
   82     82   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   83     83   
    fn serialize_members(
   84     84   
        &self,
   85     85   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   86     86   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   87     87   
        if let Some(ref val) = self.status {
   88     88   
            ser.write_string(&SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_STATUS, val.as_str())?;
   89     89   
        }
   90     90   
        {
   91     91   
            let val = &self.failure_count;
   92     92   
            ser.write_integer(&SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_FAILURE_COUNT, *val)?;
   93     93   
        }
   94     94   
        {
   95     95   
            let val = &self.threshold;
   96     96   
            ser.write_integer(&SERVICEDEPLOYMENTCIRCUITBREAKER_MEMBER_THRESHOLD, *val)?;
   97     97   
        }
   98     98   
        Ok(())
   99     99   
    }
  100    100   
}
  101    101   
impl ServiceDeploymentCircuitBreaker {
  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(&SERVICEDEPLOYMENTCIRCUITBREAKER_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&SERVICEDEPLOYMENTCIRCUITBREAKER_SCHEMA, &mut |member, deser| {
  116    116   
            match member.member_index() {
  117    117   
                Some(0) => {
  118    118   
                    builder.status = Some(crate::types::ServiceDeploymentRollbackMonitorsStatus::from(
  119    119   
                        deser.read_string(member)?.as_str(),
  120    120   
                    ));
  121    121   
                }
  122    122   
                Some(1) => {
  123    123   
                    builder.failure_count = Some(deser.read_integer(member)?);
  124    124   
                }
  125    125   
                Some(2) => {
  126    126   
                    builder.threshold = Some(deser.read_integer(member)?);
  127    127   
                }
  128    128   
                _ => {}
  129    129   
            }
  130    130   
            Ok(())
  131    131   
        })?;
  132    132   
        Ok(builder.build())
  133    133   
    }
  134    134   
}
         135  +
impl ServiceDeploymentCircuitBreaker {
         136  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         137  +
    pub fn deserialize_with_response(
         138  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         139  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         140  +
        _status: u16,
         141  +
        _body: &[u8],
         142  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         143  +
        Self::deserialize(deserializer)
         144  +
    }
         145  +
}
  135    146   
impl ServiceDeploymentCircuitBreaker {
  136    147   
    /// Creates a new builder-style object to manufacture [`ServiceDeploymentCircuitBreaker`](crate::types::ServiceDeploymentCircuitBreaker).
  137    148   
    pub fn builder() -> crate::types::builders::ServiceDeploymentCircuitBreakerBuilder {
  138    149   
        crate::types::builders::ServiceDeploymentCircuitBreakerBuilder::default()
  139    150   
    }
  140    151   
}
  141    152   
  142    153   
/// A builder for [`ServiceDeploymentCircuitBreaker`](crate::types::ServiceDeploymentCircuitBreaker).
  143    154   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  144    155   
#[non_exhaustive]

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

@@ -9,9 +136,147 @@
   29     29   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceEvent", "com.amazonaws.ecs", "ServiceEvent");
   30     30   
static SERVICEEVENT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceEvent$id", "com.amazonaws.ecs", "ServiceEvent"),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33     33   
    "id",
   34     34   
    0,
   35     35   
);
   36     36   
static SERVICEEVENT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceEvent$createdAt", "com.amazonaws.ecs", "ServiceEvent"),
   38     38   
    ::aws_smithy_schema::ShapeType::Timestamp,
   39         -
    "created_at",
          39  +
    "createdAt",
   40     40   
    1,
   41     41   
);
   42     42   
static SERVICEEVENT_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceEvent$message", "com.amazonaws.ecs", "ServiceEvent"),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45     45   
    "message",
   46     46   
    2,
   47     47   
);
   48     48   
static SERVICEEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    SERVICEEVENT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&SERVICEEVENT_MEMBER_ID, &SERVICEEVENT_MEMBER_CREATED_AT, &SERVICEEVENT_MEMBER_MESSAGE],
   52     52   
);
   53     53   
impl ServiceEvent {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEEVENT_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceEvent {
   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   
        if let Some(ref val) = self.id {
   64     64   
            ser.write_string(&SERVICEEVENT_MEMBER_ID, val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.created_at {
   67     67   
            ser.write_timestamp(&SERVICEEVENT_MEMBER_CREATED_AT, val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.message {
   70     70   
            ser.write_string(&SERVICEEVENT_MEMBER_MESSAGE, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl ServiceEvent {
   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(&SERVICEEVENT_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&SERVICEEVENT_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.id = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.created_at = Some(deser.read_timestamp(member)?);
   96     96   
                }
   97     97   
                Some(2) => {
   98     98   
                    builder.message = Some(deser.read_string(member)?);
   99     99   
                }
  100    100   
                _ => {}
  101    101   
            }
  102    102   
            Ok(())
  103    103   
        })?;
  104    104   
        Ok(builder.build())
  105    105   
    }
  106    106   
}
         107  +
impl ServiceEvent {
         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 ServiceEvent {
  108    119   
    /// Creates a new builder-style object to manufacture [`ServiceEvent`](crate::types::ServiceEvent).
  109    120   
    pub fn builder() -> crate::types::builders::ServiceEventBuilder {
  110    121   
        crate::types::builders::ServiceEventBuilder::default()
  111    122   
    }
  112    123   
}
  113    124   
  114    125   
/// A builder for [`ServiceEvent`](crate::types::ServiceEvent).
  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/_service_managed_ebs_volume_configuration.rs

@@ -158,158 +308,308 @@
  178    178   
    "encrypted",
  179    179   
    0,
  180    180   
);
  181    181   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  182    182   
    ::aws_smithy_schema::ShapeId::from_static(
  183    183   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$kmsKeyId",
  184    184   
        "com.amazonaws.ecs",
  185    185   
        "ServiceManagedEBSVolumeConfiguration",
  186    186   
    ),
  187    187   
    ::aws_smithy_schema::ShapeType::String,
  188         -
    "kms_key_id",
         188  +
    "kmsKeyId",
  189    189   
    1,
  190    190   
);
  191    191   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_VOLUME_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static(
  193    193   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$volumeType",
  194    194   
        "com.amazonaws.ecs",
  195    195   
        "ServiceManagedEBSVolumeConfiguration",
  196    196   
    ),
  197    197   
    ::aws_smithy_schema::ShapeType::String,
  198         -
    "volume_type",
         198  +
    "volumeType",
  199    199   
    2,
  200    200   
);
  201    201   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_SIZE_IN_GIB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  202    202   
    ::aws_smithy_schema::ShapeId::from_static(
  203    203   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$sizeInGiB",
  204    204   
        "com.amazonaws.ecs",
  205    205   
        "ServiceManagedEBSVolumeConfiguration",
  206    206   
    ),
  207    207   
    ::aws_smithy_schema::ShapeType::Integer,
  208         -
    "size_in_gib",
         208  +
    "sizeInGiB",
  209    209   
    3,
  210    210   
);
  211    211   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static(
  213    213   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$snapshotId",
  214    214   
        "com.amazonaws.ecs",
  215    215   
        "ServiceManagedEBSVolumeConfiguration",
  216    216   
    ),
  217    217   
    ::aws_smithy_schema::ShapeType::String,
  218         -
    "snapshot_id",
         218  +
    "snapshotId",
  219    219   
    4,
  220    220   
);
  221    221   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_VOLUME_INITIALIZATION_RATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  222    222   
    ::aws_smithy_schema::ShapeId::from_static(
  223    223   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$volumeInitializationRate",
  224    224   
        "com.amazonaws.ecs",
  225    225   
        "ServiceManagedEBSVolumeConfiguration",
  226    226   
    ),
  227    227   
    ::aws_smithy_schema::ShapeType::Integer,
  228         -
    "volume_initialization_rate",
         228  +
    "volumeInitializationRate",
  229    229   
    5,
  230    230   
);
  231    231   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_IOPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  232    232   
    ::aws_smithy_schema::ShapeId::from_static(
  233    233   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$iops",
  234    234   
        "com.amazonaws.ecs",
  235    235   
        "ServiceManagedEBSVolumeConfiguration",
  236    236   
    ),
  237    237   
    ::aws_smithy_schema::ShapeType::Integer,
  238    238   
    "iops",
  239    239   
    6,
  240    240   
);
  241    241   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_THROUGHPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  242    242   
    ::aws_smithy_schema::ShapeId::from_static(
  243    243   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$throughput",
  244    244   
        "com.amazonaws.ecs",
  245    245   
        "ServiceManagedEBSVolumeConfiguration",
  246    246   
    ),
  247    247   
    ::aws_smithy_schema::ShapeType::Integer,
  248    248   
    "throughput",
  249    249   
    7,
  250    250   
);
  251    251   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  252    252   
    ::aws_smithy_schema::ShapeId::from_static(
  253    253   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$tagSpecifications",
  254    254   
        "com.amazonaws.ecs",
  255    255   
        "ServiceManagedEBSVolumeConfiguration",
  256    256   
    ),
  257    257   
    ::aws_smithy_schema::ShapeType::List,
  258         -
    "tag_specifications",
         258  +
    "tagSpecifications",
  259    259   
    8,
  260    260   
);
  261    261   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  262    262   
    ::aws_smithy_schema::ShapeId::from_static(
  263    263   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$roleArn",
  264    264   
        "com.amazonaws.ecs",
  265    265   
        "ServiceManagedEBSVolumeConfiguration",
  266    266   
    ),
  267    267   
    ::aws_smithy_schema::ShapeType::String,
  268         -
    "role_arn",
         268  +
    "roleArn",
  269    269   
    9,
  270    270   
);
  271    271   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_FILESYSTEM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  272    272   
    ::aws_smithy_schema::ShapeId::from_static(
  273    273   
        "com.amazonaws.ecs#ServiceManagedEBSVolumeConfiguration$filesystemType",
  274    274   
        "com.amazonaws.ecs",
  275    275   
        "ServiceManagedEBSVolumeConfiguration",
  276    276   
    ),
  277    277   
    ::aws_smithy_schema::ShapeType::String,
  278         -
    "filesystem_type",
         278  +
    "filesystemType",
  279    279   
    10,
  280    280   
);
  281    281   
static SERVICEMANAGEDEBSVOLUMECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  282    282   
    SERVICEMANAGEDEBSVOLUMECONFIGURATION_SCHEMA_ID,
  283    283   
    ::aws_smithy_schema::ShapeType::Structure,
  284    284   
    &[
  285    285   
        &SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_ENCRYPTED,
  286    286   
        &SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_KMS_KEY_ID,
  287    287   
        &SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_VOLUME_TYPE,
  288    288   
        &SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_SIZE_IN_GIB,
@@ -325,325 +450,459 @@
  345    345   
            ser.write_string(&SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_ROLE_ARN, val)?;
  346    346   
        }
  347    347   
        if let Some(ref val) = self.filesystem_type {
  348    348   
            ser.write_string(&SERVICEMANAGEDEBSVOLUMECONFIGURATION_MEMBER_FILESYSTEM_TYPE, val.as_str())?;
  349    349   
        }
  350    350   
        Ok(())
  351    351   
    }
  352    352   
}
  353    353   
impl ServiceManagedEbsVolumeConfiguration {
  354    354   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  355         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  356         -
        deserializer: &mut D,
         355  +
    pub fn deserialize(
         356  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  357    357   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  358    358   
        #[allow(unused_variables, unused_mut)]
  359    359   
        let mut builder = Self::builder();
  360    360   
        #[allow(
  361    361   
            unused_variables,
  362    362   
            unreachable_code,
  363    363   
            clippy::single_match,
  364    364   
            clippy::match_single_binding,
  365    365   
            clippy::diverging_sub_expression
  366    366   
        )]
  367         -
        deserializer.read_struct(&SERVICEMANAGEDEBSVOLUMECONFIGURATION_SCHEMA, (), |_, member, deser| {
         367  +
        deserializer.read_struct(&SERVICEMANAGEDEBSVOLUMECONFIGURATION_SCHEMA, &mut |member, deser| {
  368    368   
            match member.member_index() {
  369    369   
                Some(0) => {
  370    370   
                    builder.encrypted = Some(deser.read_boolean(member)?);
  371    371   
                }
  372    372   
                Some(1) => {
  373    373   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  374    374   
                }
  375    375   
                Some(2) => {
  376    376   
                    builder.volume_type = Some(deser.read_string(member)?);
  377    377   
                }
  378    378   
                Some(3) => {
  379    379   
                    builder.size_in_gib = Some(deser.read_integer(member)?);
  380    380   
                }
  381    381   
                Some(4) => {
  382    382   
                    builder.snapshot_id = Some(deser.read_string(member)?);
  383    383   
                }
  384    384   
                Some(5) => {
  385    385   
                    builder.volume_initialization_rate = Some(deser.read_integer(member)?);
  386    386   
                }
  387    387   
                Some(6) => {
  388    388   
                    builder.iops = Some(deser.read_integer(member)?);
  389    389   
                }
  390    390   
                Some(7) => {
  391    391   
                    builder.throughput = Some(deser.read_integer(member)?);
  392    392   
                }
  393    393   
                Some(8) => {
  394    394   
                    builder.tag_specifications = Some({
  395         -
                        let container = if let Some(cap) = deser.container_size() {
  396         -
                            Vec::with_capacity(cap)
  397         -
                        } else {
  398         -
                            Vec::new()
  399         -
                        };
  400         -
                        deser.read_list(member, container, |mut list, deser| {
  401         -
                            list.push(crate::types::EbsTagSpecification::deserialize(deser)?);
  402         -
                            Ok(list)
  403         -
                        })?
         395  +
                        let mut container = Vec::new();
         396  +
                        deser.read_list(member, &mut |deser| {
         397  +
                            container.push(crate::types::EbsTagSpecification::deserialize(deser)?);
         398  +
                            Ok(())
         399  +
                        })?;
         400  +
                        container
  404    401   
                    });
  405    402   
                }
  406    403   
                Some(9) => {
  407    404   
                    builder.role_arn = Some(deser.read_string(member)?);
  408    405   
                }
  409    406   
                Some(10) => {
  410    407   
                    builder.filesystem_type = Some(crate::types::TaskFilesystemType::from(deser.read_string(member)?.as_str()));
  411    408   
                }
  412    409   
                _ => {}
  413    410   
            }
  414    411   
            Ok(())
  415    412   
        })?;
         413  +
        builder.role_arn = builder.role_arn.or(Some(String::new()));
  416    414   
        builder
  417    415   
            .build()
  418    416   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  419    417   
    }
  420    418   
}
         419  +
impl ServiceManagedEbsVolumeConfiguration {
         420  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         421  +
    pub fn deserialize_with_response(
         422  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         423  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         424  +
        _status: u16,
         425  +
        _body: &[u8],
         426  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         427  +
        Self::deserialize(deserializer)
         428  +
    }
         429  +
}
  421    430   
impl ServiceManagedEbsVolumeConfiguration {
  422    431   
    /// Creates a new builder-style object to manufacture [`ServiceManagedEbsVolumeConfiguration`](crate::types::ServiceManagedEbsVolumeConfiguration).
  423    432   
    pub fn builder() -> crate::types::builders::ServiceManagedEbsVolumeConfigurationBuilder {
  424    433   
        crate::types::builders::ServiceManagedEbsVolumeConfigurationBuilder::default()
  425    434   
    }
  426    435   
}
  427    436   
  428    437   
/// A builder for [`ServiceManagedEbsVolumeConfiguration`](crate::types::ServiceManagedEbsVolumeConfiguration).
  429    438   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  430    439   
#[non_exhaustive]

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

@@ -11,11 +161,172 @@
   31     31   
    /// <p>The port value to be used for your service discovery service. It's already specified in the task definition. If the task definition your service task specifies uses the <code>bridge</code> or <code>host</code> network mode, you must specify a <code>containerName</code> and <code>containerPort</code> combination from the task definition. If the task definition your service task specifies uses the <code>awsvpc</code> network mode and a type SRV DNS record is used, you must specify either a <code>containerName</code> and <code>containerPort</code> combination or a <code>port</code> value. However, you can't specify both.</p>
   32     32   
    pub fn container_port(&self) -> ::std::option::Option<i32> {
   33     33   
        self.container_port
   34     34   
    }
   35     35   
}
   36     36   
static SERVICEREGISTRY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRegistry", "com.amazonaws.ecs", "ServiceRegistry");
   38     38   
static SERVICEREGISTRY_MEMBER_REGISTRY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRegistry$registryArn", "com.amazonaws.ecs", "ServiceRegistry"),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "registry_arn",
          41  +
    "registryArn",
   42     42   
    0,
   43     43   
);
   44     44   
static SERVICEREGISTRY_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRegistry$port", "com.amazonaws.ecs", "ServiceRegistry"),
   46     46   
    ::aws_smithy_schema::ShapeType::Integer,
   47     47   
    "port",
   48     48   
    1,
   49     49   
);
   50     50   
static SERVICEREGISTRY_MEMBER_CONTAINER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRegistry$containerName", "com.amazonaws.ecs", "ServiceRegistry"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "container_name",
          53  +
    "containerName",
   54     54   
    2,
   55     55   
);
   56     56   
static SERVICEREGISTRY_MEMBER_CONTAINER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRegistry$containerPort", "com.amazonaws.ecs", "ServiceRegistry"),
   58     58   
    ::aws_smithy_schema::ShapeType::Integer,
   59         -
    "container_port",
          59  +
    "containerPort",
   60     60   
    3,
   61     61   
);
   62     62   
static SERVICEREGISTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    SERVICEREGISTRY_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[
   66     66   
        &SERVICEREGISTRY_MEMBER_REGISTRY_ARN,
   67     67   
        &SERVICEREGISTRY_MEMBER_PORT,
   68     68   
        &SERVICEREGISTRY_MEMBER_CONTAINER_NAME,
   69     69   
        &SERVICEREGISTRY_MEMBER_CONTAINER_PORT,
   70     70   
    ],
   71     71   
);
   72     72   
impl ServiceRegistry {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEREGISTRY_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceRegistry {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.registry_arn {
   83     83   
            ser.write_string(&SERVICEREGISTRY_MEMBER_REGISTRY_ARN, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.port {
   86     86   
            ser.write_integer(&SERVICEREGISTRY_MEMBER_PORT, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.container_name {
   89     89   
            ser.write_string(&SERVICEREGISTRY_MEMBER_CONTAINER_NAME, val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.container_port {
   92     92   
            ser.write_integer(&SERVICEREGISTRY_MEMBER_CONTAINER_PORT, *val)?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl ServiceRegistry {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&SERVICEREGISTRY_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&SERVICEREGISTRY_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.registry_arn = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.port = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                Some(2) => {
  120    120   
                    builder.container_name = Some(deser.read_string(member)?);
  121    121   
                }
  122    122   
                Some(3) => {
  123    123   
                    builder.container_port = Some(deser.read_integer(member)?);
  124    124   
                }
  125    125   
                _ => {}
  126    126   
            }
  127    127   
            Ok(())
  128    128   
        })?;
  129    129   
        Ok(builder.build())
  130    130   
    }
  131    131   
}
         132  +
impl ServiceRegistry {
         133  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         134  +
    pub fn deserialize_with_response(
         135  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         136  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         137  +
        _status: u16,
         138  +
        _body: &[u8],
         139  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         140  +
        Self::deserialize(deserializer)
         141  +
    }
         142  +
}
  132    143   
impl ServiceRegistry {
  133    144   
    /// Creates a new builder-style object to manufacture [`ServiceRegistry`](crate::types::ServiceRegistry).
  134    145   
    pub fn builder() -> crate::types::builders::ServiceRegistryBuilder {
  135    146   
        crate::types::builders::ServiceRegistryBuilder::default()
  136    147   
    }
  137    148   
}
  138    149   
  139    150   
/// A builder for [`ServiceRegistry`](crate::types::ServiceRegistry).
  140    151   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  141    152   
#[non_exhaustive]

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

@@ -118,118 +330,330 @@
  138    138   
}
  139    139   
static SERVICEREVISION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  140    140   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision", "com.amazonaws.ecs", "ServiceRevision");
  141    141   
static SERVICEREVISION_MEMBER_SERVICE_REVISION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.ecs#ServiceRevision$serviceRevisionArn",
  144    144   
        "com.amazonaws.ecs",
  145    145   
        "ServiceRevision",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "service_revision_arn",
         148  +
    "serviceRevisionArn",
  149    149   
    0,
  150    150   
);
  151    151   
static SERVICEREVISION_MEMBER_SERVICE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$serviceArn", "com.amazonaws.ecs", "ServiceRevision"),
  153    153   
    ::aws_smithy_schema::ShapeType::String,
  154         -
    "service_arn",
         154  +
    "serviceArn",
  155    155   
    1,
  156    156   
);
  157    157   
static SERVICEREVISION_MEMBER_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$clusterArn", "com.amazonaws.ecs", "ServiceRevision"),
  159    159   
    ::aws_smithy_schema::ShapeType::String,
  160         -
    "cluster_arn",
         160  +
    "clusterArn",
  161    161   
    2,
  162    162   
);
  163    163   
static SERVICEREVISION_MEMBER_TASK_DEFINITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$taskDefinition", "com.amazonaws.ecs", "ServiceRevision"),
  165    165   
    ::aws_smithy_schema::ShapeType::String,
  166         -
    "task_definition",
         166  +
    "taskDefinition",
  167    167   
    3,
  168    168   
);
  169    169   
static SERVICEREVISION_MEMBER_CAPACITY_PROVIDER_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ecs#ServiceRevision$capacityProviderStrategy",
  172    172   
        "com.amazonaws.ecs",
  173    173   
        "ServiceRevision",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::List,
  176         -
    "capacity_provider_strategy",
         176  +
    "capacityProviderStrategy",
  177    177   
    4,
  178    178   
);
  179    179   
static SERVICEREVISION_MEMBER_LAUNCH_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$launchType", "com.amazonaws.ecs", "ServiceRevision"),
  181    181   
    ::aws_smithy_schema::ShapeType::String,
  182         -
    "launch_type",
         182  +
    "launchType",
  183    183   
    5,
  184    184   
);
  185    185   
static SERVICEREVISION_MEMBER_PLATFORM_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static(
  187    187   
        "com.amazonaws.ecs#ServiceRevision$platformVersion",
  188    188   
        "com.amazonaws.ecs",
  189    189   
        "ServiceRevision",
  190    190   
    ),
  191    191   
    ::aws_smithy_schema::ShapeType::String,
  192         -
    "platform_version",
         192  +
    "platformVersion",
  193    193   
    6,
  194    194   
);
  195    195   
static SERVICEREVISION_MEMBER_PLATFORM_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$platformFamily", "com.amazonaws.ecs", "ServiceRevision"),
  197    197   
    ::aws_smithy_schema::ShapeType::String,
  198         -
    "platform_family",
         198  +
    "platformFamily",
  199    199   
    7,
  200    200   
);
  201    201   
static SERVICEREVISION_MEMBER_LOAD_BALANCERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  202    202   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$loadBalancers", "com.amazonaws.ecs", "ServiceRevision"),
  203    203   
    ::aws_smithy_schema::ShapeType::List,
  204         -
    "load_balancers",
         204  +
    "loadBalancers",
  205    205   
    8,
  206    206   
);
  207    207   
static SERVICEREVISION_MEMBER_SERVICE_REGISTRIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  208    208   
    ::aws_smithy_schema::ShapeId::from_static(
  209    209   
        "com.amazonaws.ecs#ServiceRevision$serviceRegistries",
  210    210   
        "com.amazonaws.ecs",
  211    211   
        "ServiceRevision",
  212    212   
    ),
  213    213   
    ::aws_smithy_schema::ShapeType::List,
  214         -
    "service_registries",
         214  +
    "serviceRegistries",
  215    215   
    9,
  216    216   
);
  217    217   
static SERVICEREVISION_MEMBER_NETWORK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    218   
    ::aws_smithy_schema::ShapeId::from_static(
  219    219   
        "com.amazonaws.ecs#ServiceRevision$networkConfiguration",
  220    220   
        "com.amazonaws.ecs",
  221    221   
        "ServiceRevision",
  222    222   
    ),
  223    223   
    ::aws_smithy_schema::ShapeType::Structure,
  224         -
    "network_configuration",
         224  +
    "networkConfiguration",
  225    225   
    10,
  226    226   
);
  227    227   
static SERVICEREVISION_MEMBER_CONTAINER_IMAGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static(
  229    229   
        "com.amazonaws.ecs#ServiceRevision$containerImages",
  230    230   
        "com.amazonaws.ecs",
  231    231   
        "ServiceRevision",
  232    232   
    ),
  233    233   
    ::aws_smithy_schema::ShapeType::List,
  234         -
    "container_images",
         234  +
    "containerImages",
  235    235   
    11,
  236    236   
);
  237    237   
static SERVICEREVISION_MEMBER_GUARD_DUTY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  238    238   
    ::aws_smithy_schema::ShapeId::from_static(
  239    239   
        "com.amazonaws.ecs#ServiceRevision$guardDutyEnabled",
  240    240   
        "com.amazonaws.ecs",
  241    241   
        "ServiceRevision",
  242    242   
    ),
  243    243   
    ::aws_smithy_schema::ShapeType::Boolean,
  244         -
    "guard_duty_enabled",
         244  +
    "guardDutyEnabled",
  245    245   
    12,
  246    246   
);
  247    247   
static SERVICEREVISION_MEMBER_SERVICE_CONNECT_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  248    248   
    ::aws_smithy_schema::ShapeId::from_static(
  249    249   
        "com.amazonaws.ecs#ServiceRevision$serviceConnectConfiguration",
  250    250   
        "com.amazonaws.ecs",
  251    251   
        "ServiceRevision",
  252    252   
    ),
  253    253   
    ::aws_smithy_schema::ShapeType::Structure,
  254         -
    "service_connect_configuration",
         254  +
    "serviceConnectConfiguration",
  255    255   
    13,
  256    256   
);
  257    257   
static SERVICEREVISION_MEMBER_VOLUME_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  258    258   
    ::aws_smithy_schema::ShapeId::from_static(
  259    259   
        "com.amazonaws.ecs#ServiceRevision$volumeConfigurations",
  260    260   
        "com.amazonaws.ecs",
  261    261   
        "ServiceRevision",
  262    262   
    ),
  263    263   
    ::aws_smithy_schema::ShapeType::List,
  264         -
    "volume_configurations",
         264  +
    "volumeConfigurations",
  265    265   
    14,
  266    266   
);
  267    267   
static SERVICEREVISION_MEMBER_FARGATE_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  268    268   
    ::aws_smithy_schema::ShapeId::from_static(
  269    269   
        "com.amazonaws.ecs#ServiceRevision$fargateEphemeralStorage",
  270    270   
        "com.amazonaws.ecs",
  271    271   
        "ServiceRevision",
  272    272   
    ),
  273    273   
    ::aws_smithy_schema::ShapeType::Structure,
  274         -
    "fargate_ephemeral_storage",
         274  +
    "fargateEphemeralStorage",
  275    275   
    15,
  276    276   
);
  277    277   
static SERVICEREVISION_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  278    278   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ServiceRevision$createdAt", "com.amazonaws.ecs", "ServiceRevision"),
  279    279   
    ::aws_smithy_schema::ShapeType::Timestamp,
  280         -
    "created_at",
         280  +
    "createdAt",
  281    281   
    16,
  282    282   
);
  283    283   
static SERVICEREVISION_MEMBER_VPC_LATTICE_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  284    284   
    ::aws_smithy_schema::ShapeId::from_static(
  285    285   
        "com.amazonaws.ecs#ServiceRevision$vpcLatticeConfigurations",
  286    286   
        "com.amazonaws.ecs",
  287    287   
        "ServiceRevision",
  288    288   
    ),
  289    289   
    ::aws_smithy_schema::ShapeType::List,
  290         -
    "vpc_lattice_configurations",
         290  +
    "vpcLatticeConfigurations",
  291    291   
    17,
  292    292   
);
  293    293   
static SERVICEREVISION_MEMBER_RESOLVED_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  294    294   
    ::aws_smithy_schema::ShapeId::from_static(
  295    295   
        "com.amazonaws.ecs#ServiceRevision$resolvedConfiguration",
  296    296   
        "com.amazonaws.ecs",
  297    297   
        "ServiceRevision",
  298    298   
    ),
  299    299   
    ::aws_smithy_schema::ShapeType::Structure,
  300         -
    "resolved_configuration",
         300  +
    "resolvedConfiguration",
  301    301   
    18,
  302    302   
);
  303    303   
static SERVICEREVISION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  304    304   
    SERVICEREVISION_SCHEMA_ID,
  305    305   
    ::aws_smithy_schema::ShapeType::Structure,
  306    306   
    &[
  307    307   
        &SERVICEREVISION_MEMBER_SERVICE_REVISION_ARN,
  308    308   
        &SERVICEREVISION_MEMBER_SERVICE_ARN,
  309    309   
        &SERVICEREVISION_MEMBER_CLUSTER_ARN,
  310    310   
        &SERVICEREVISION_MEMBER_TASK_DEFINITION,
@@ -419,419 +616,609 @@
  439    439   
            )?;
  440    440   
        }
  441    441   
        if let Some(ref val) = self.resolved_configuration {
  442    442   
            ser.write_struct(&SERVICEREVISION_MEMBER_RESOLVED_CONFIGURATION, val)?;
  443    443   
        }
  444    444   
        Ok(())
  445    445   
    }
  446    446   
}
  447    447   
impl ServiceRevision {
  448    448   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  449         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  450         -
        deserializer: &mut D,
         449  +
    pub fn deserialize(
         450  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  451    451   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  452    452   
        #[allow(unused_variables, unused_mut)]
  453    453   
        let mut builder = Self::builder();
  454    454   
        #[allow(
  455    455   
            unused_variables,
  456    456   
            unreachable_code,
  457    457   
            clippy::single_match,
  458    458   
            clippy::match_single_binding,
  459    459   
            clippy::diverging_sub_expression
  460    460   
        )]
  461         -
        deserializer.read_struct(&SERVICEREVISION_SCHEMA, (), |_, member, deser| {
         461  +
        deserializer.read_struct(&SERVICEREVISION_SCHEMA, &mut |member, deser| {
  462    462   
            match member.member_index() {
  463    463   
                Some(0) => {
  464    464   
                    builder.service_revision_arn = Some(deser.read_string(member)?);
  465    465   
                }
  466    466   
                Some(1) => {
  467    467   
                    builder.service_arn = Some(deser.read_string(member)?);
  468    468   
                }
  469    469   
                Some(2) => {
  470    470   
                    builder.cluster_arn = Some(deser.read_string(member)?);
  471    471   
                }
  472    472   
                Some(3) => {
  473    473   
                    builder.task_definition = Some(deser.read_string(member)?);
  474    474   
                }
  475    475   
                Some(4) => {
  476    476   
                    builder.capacity_provider_strategy = Some({
  477         -
                        let container = if let Some(cap) = deser.container_size() {
  478         -
                            Vec::with_capacity(cap)
  479         -
                        } else {
  480         -
                            Vec::new()
  481         -
                        };
  482         -
                        deser.read_list(member, container, |mut list, deser| {
  483         -
                            list.push(crate::types::CapacityProviderStrategyItem::deserialize(deser)?);
  484         -
                            Ok(list)
  485         -
                        })?
         477  +
                        let mut container = Vec::new();
         478  +
                        deser.read_list(member, &mut |deser| {
         479  +
                            container.push(crate::types::CapacityProviderStrategyItem::deserialize(deser)?);
         480  +
                            Ok(())
         481  +
                        })?;
         482  +
                        container
  486    483   
                    });
  487    484   
                }
  488    485   
                Some(5) => {
  489    486   
                    builder.launch_type = Some(crate::types::LaunchType::from(deser.read_string(member)?.as_str()));
  490    487   
                }
  491    488   
                Some(6) => {
  492    489   
                    builder.platform_version = Some(deser.read_string(member)?);
  493    490   
                }
  494    491   
                Some(7) => {
  495    492   
                    builder.platform_family = Some(deser.read_string(member)?);
  496    493   
                }
  497    494   
                Some(8) => {
  498    495   
                    builder.load_balancers = Some({
  499         -
                        let container = if let Some(cap) = deser.container_size() {
  500         -
                            Vec::with_capacity(cap)
  501         -
                        } else {
  502         -
                            Vec::new()
  503         -
                        };
  504         -
                        deser.read_list(member, container, |mut list, deser| {
  505         -
                            list.push(crate::types::LoadBalancer::deserialize(deser)?);
  506         -
                            Ok(list)
  507         -
                        })?
         496  +
                        let mut container = Vec::new();
         497  +
                        deser.read_list(member, &mut |deser| {
         498  +
                            container.push(crate::types::LoadBalancer::deserialize(deser)?);
         499  +
                            Ok(())
         500  +
                        })?;
         501  +
                        container
  508    502   
                    });
  509    503   
                }
  510    504   
                Some(9) => {
  511    505   
                    builder.service_registries = Some({
  512         -
                        let container = if let Some(cap) = deser.container_size() {
  513         -
                            Vec::with_capacity(cap)
  514         -
                        } else {
  515         -
                            Vec::new()
  516         -
                        };
  517         -
                        deser.read_list(member, container, |mut list, deser| {
  518         -
                            list.push(crate::types::ServiceRegistry::deserialize(deser)?);
  519         -
                            Ok(list)
  520         -
                        })?
         506  +
                        let mut container = Vec::new();
         507  +
                        deser.read_list(member, &mut |deser| {
         508  +
                            container.push(crate::types::ServiceRegistry::deserialize(deser)?);
         509  +
                            Ok(())
         510  +
                        })?;
         511  +
                        container
  521    512   
                    });
  522    513   
                }
  523    514   
                Some(10) => {
  524    515   
                    builder.network_configuration = Some(crate::types::NetworkConfiguration::deserialize(deser)?);
  525    516   
                }
  526    517   
                Some(11) => {
  527    518   
                    builder.container_images = Some({
  528         -
                        let container = if let Some(cap) = deser.container_size() {
  529         -
                            Vec::with_capacity(cap)
  530         -
                        } else {
  531         -
                            Vec::new()
  532         -
                        };
  533         -
                        deser.read_list(member, container, |mut list, deser| {
  534         -
                            list.push(crate::types::ContainerImage::deserialize(deser)?);
  535         -
                            Ok(list)
  536         -
                        })?
         519  +
                        let mut container = Vec::new();
         520  +
                        deser.read_list(member, &mut |deser| {
         521  +
                            container.push(crate::types::ContainerImage::deserialize(deser)?);
         522  +
                            Ok(())
         523  +
                        })?;
         524  +
                        container
  537    525   
                    });
  538    526   
                }
  539    527   
                Some(12) => {
  540    528   
                    builder.guard_duty_enabled = Some(deser.read_boolean(member)?);
  541    529   
                }
  542    530   
                Some(13) => {
  543    531   
                    builder.service_connect_configuration = Some(crate::types::ServiceConnectConfiguration::deserialize(deser)?);
  544    532   
                }
  545    533   
                Some(14) => {
  546    534   
                    builder.volume_configurations = Some({
  547         -
                        let container = if let Some(cap) = deser.container_size() {
  548         -
                            Vec::with_capacity(cap)
  549         -
                        } else {
  550         -
                            Vec::new()
  551         -
                        };
  552         -
                        deser.read_list(member, container, |mut list, deser| {
  553         -
                            list.push(crate::types::ServiceVolumeConfiguration::deserialize(deser)?);
  554         -
                            Ok(list)
  555         -
                        })?
         535  +
                        let mut container = Vec::new();
         536  +
                        deser.read_list(member, &mut |deser| {
         537  +
                            container.push(crate::types::ServiceVolumeConfiguration::deserialize(deser)?);
         538  +
                            Ok(())
         539  +
                        })?;
         540  +
                        container
  556    541   
                    });
  557    542   
                }
  558    543   
                Some(15) => {
  559    544   
                    builder.fargate_ephemeral_storage = Some(crate::types::DeploymentEphemeralStorage::deserialize(deser)?);
  560    545   
                }
  561    546   
                Some(16) => {
  562    547   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  563    548   
                }
  564    549   
                Some(17) => {
  565    550   
                    builder.vpc_lattice_configurations = Some({
  566         -
                        let container = if let Some(cap) = deser.container_size() {
  567         -
                            Vec::with_capacity(cap)
  568         -
                        } else {
  569         -
                            Vec::new()
  570         -
                        };
  571         -
                        deser.read_list(member, container, |mut list, deser| {
  572         -
                            list.push(crate::types::VpcLatticeConfiguration::deserialize(deser)?);
  573         -
                            Ok(list)
  574         -
                        })?
         551  +
                        let mut container = Vec::new();
         552  +
                        deser.read_list(member, &mut |deser| {
         553  +
                            container.push(crate::types::VpcLatticeConfiguration::deserialize(deser)?);
         554  +
                            Ok(())
         555  +
                        })?;
         556  +
                        container
  575    557   
                    });
  576    558   
                }
  577    559   
                Some(18) => {
  578    560   
                    builder.resolved_configuration = Some(crate::types::ResolvedConfiguration::deserialize(deser)?);
  579    561   
                }
  580    562   
                _ => {}
  581    563   
            }
  582    564   
            Ok(())
  583    565   
        })?;
  584    566   
        Ok(builder.build())
  585    567   
    }
  586    568   
}
         569  +
impl ServiceRevision {
         570  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         571  +
    pub fn deserialize_with_response(
         572  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         573  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         574  +
        _status: u16,
         575  +
        _body: &[u8],
         576  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         577  +
        Self::deserialize(deserializer)
         578  +
    }
         579  +
}
  587    580   
impl ServiceRevision {
  588    581   
    /// Creates a new builder-style object to manufacture [`ServiceRevision`](crate::types::ServiceRevision).
  589    582   
    pub fn builder() -> crate::types::builders::ServiceRevisionBuilder {
  590    583   
        crate::types::builders::ServiceRevisionBuilder::default()
  591    584   
    }
  592    585   
}
  593    586   
  594    587   
/// A builder for [`ServiceRevision`](crate::types::ServiceRevision).
  595    588   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  596    589   
#[non_exhaustive]

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

@@ -4,4 +132,143 @@
   24     24   
    "com.amazonaws.ecs",
   25     25   
    "ServiceRevisionLoadBalancer",
   26     26   
);
   27     27   
static SERVICEREVISIONLOADBALANCER_MEMBER_TARGET_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.ecs#ServiceRevisionLoadBalancer$targetGroupArn",
   30     30   
        "com.amazonaws.ecs",
   31     31   
        "ServiceRevisionLoadBalancer",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "target_group_arn",
          34  +
    "targetGroupArn",
   35     35   
    0,
   36     36   
);
   37     37   
static SERVICEREVISIONLOADBALANCER_MEMBER_PRODUCTION_LISTENER_RULE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.ecs#ServiceRevisionLoadBalancer$productionListenerRule",
   40     40   
        "com.amazonaws.ecs",
   41     41   
        "ServiceRevisionLoadBalancer",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "production_listener_rule",
          44  +
    "productionListenerRule",
   45     45   
    1,
   46     46   
);
   47     47   
static SERVICEREVISIONLOADBALANCER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    SERVICEREVISIONLOADBALANCER_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &SERVICEREVISIONLOADBALANCER_MEMBER_TARGET_GROUP_ARN,
   52     52   
        &SERVICEREVISIONLOADBALANCER_MEMBER_PRODUCTION_LISTENER_RULE,
   53     53   
    ],
   54     54   
);
   55     55   
impl ServiceRevisionLoadBalancer {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEREVISIONLOADBALANCER_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceRevisionLoadBalancer {
   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.target_group_arn {
   66     66   
            ser.write_string(&SERVICEREVISIONLOADBALANCER_MEMBER_TARGET_GROUP_ARN, val)?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.production_listener_rule {
   69     69   
            ser.write_string(&SERVICEREVISIONLOADBALANCER_MEMBER_PRODUCTION_LISTENER_RULE, val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl ServiceRevisionLoadBalancer {
   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(&SERVICEREVISIONLOADBALANCER_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&SERVICEREVISIONLOADBALANCER_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.target_group_arn = Some(deser.read_string(member)?);
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.production_listener_rule = 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 ServiceRevisionLoadBalancer {
         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 ServiceRevisionLoadBalancer {
  104    115   
    /// Creates a new builder-style object to manufacture [`ServiceRevisionLoadBalancer`](crate::types::ServiceRevisionLoadBalancer).
  105    116   
    pub fn builder() -> crate::types::builders::ServiceRevisionLoadBalancerBuilder {
  106    117   
        crate::types::builders::ServiceRevisionLoadBalancerBuilder::default()
  107    118   
    }
  108    119   
}
  109    120   
  110    121   
/// A builder for [`ServiceRevisionLoadBalancer`](crate::types::ServiceRevisionLoadBalancer).
  111    122   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    123   
#[non_exhaustive]