AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_integration_summary.rs

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

@@ -46,46 +227,240 @@
   66     66   
    "key",
   67     67   
    1,
   68     68   
);
   69     69   
static LISTTOMAP_MEMBER_VALUE_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.cloudwatchlogs#ListToMap$valueKey",
   72     72   
        "com.amazonaws.cloudwatchlogs",
   73     73   
        "ListToMap",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "value_key",
          76  +
    "valueKey",
   77     77   
    2,
   78     78   
);
   79     79   
static LISTTOMAP_MEMBER_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.cloudwatchlogs#ListToMap$target",
   82     82   
        "com.amazonaws.cloudwatchlogs",
   83     83   
        "ListToMap",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86     86   
    "target",
   87     87   
    3,
   88     88   
);
   89     89   
static LISTTOMAP_MEMBER_FLATTEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.cloudwatchlogs#ListToMap$flatten",
   92     92   
        "com.amazonaws.cloudwatchlogs",
   93     93   
        "ListToMap",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Boolean,
   96     96   
    "flatten",
   97     97   
    4,
   98     98   
);
   99     99   
static LISTTOMAP_MEMBER_FLATTENED_ELEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.cloudwatchlogs#ListToMap$flattenedElement",
  102    102   
        "com.amazonaws.cloudwatchlogs",
  103    103   
        "ListToMap",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "flattened_element",
         106  +
    "flattenedElement",
  107    107   
    5,
  108    108   
);
  109    109   
static LISTTOMAP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  110    110   
    LISTTOMAP_SCHEMA_ID,
  111    111   
    ::aws_smithy_schema::ShapeType::Structure,
  112    112   
    &[
  113    113   
        &LISTTOMAP_MEMBER_SOURCE,
  114    114   
        &LISTTOMAP_MEMBER_KEY,
  115    115   
        &LISTTOMAP_MEMBER_VALUE_KEY,
  116    116   
        &LISTTOMAP_MEMBER_TARGET,
  117    117   
        &LISTTOMAP_MEMBER_FLATTEN,
  118    118   
        &LISTTOMAP_MEMBER_FLATTENED_ELEMENT,
  119    119   
    ],
  120    120   
);
  121    121   
impl ListToMap {
  122    122   
    /// The schema for this shape.
  123    123   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTOMAP_SCHEMA;
  124    124   
}
  125    125   
impl ::aws_smithy_schema::serde::SerializableStruct for ListToMap {
  126    126   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  127    127   
    fn serialize_members(
  128    128   
        &self,
  129    129   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  130    130   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  131    131   
        {
  132    132   
            let val = &self.source;
  133    133   
            ser.write_string(&LISTTOMAP_MEMBER_SOURCE, val)?;
  134    134   
        }
  135    135   
        {
  136    136   
            let val = &self.key;
  137    137   
            ser.write_string(&LISTTOMAP_MEMBER_KEY, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.value_key {
  140    140   
            ser.write_string(&LISTTOMAP_MEMBER_VALUE_KEY, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.target {
  143    143   
            ser.write_string(&LISTTOMAP_MEMBER_TARGET, val)?;
  144    144   
        }
  145    145   
        {
  146    146   
            let val = &self.flatten;
  147    147   
            ser.write_boolean(&LISTTOMAP_MEMBER_FLATTEN, *val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.flattened_element {
  150    150   
            ser.write_string(&LISTTOMAP_MEMBER_FLATTENED_ELEMENT, val.as_str())?;
  151    151   
        }
  152    152   
        Ok(())
  153    153   
    }
  154    154   
}
  155    155   
impl ListToMap {
  156    156   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  157         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  158         -
        deserializer: &mut D,
         157  +
    pub fn deserialize(
         158  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  159    159   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  160    160   
        #[allow(unused_variables, unused_mut)]
  161    161   
        let mut builder = Self::builder();
  162    162   
        #[allow(
  163    163   
            unused_variables,
  164    164   
            unreachable_code,
  165    165   
            clippy::single_match,
  166    166   
            clippy::match_single_binding,
  167    167   
            clippy::diverging_sub_expression
  168    168   
        )]
  169         -
        deserializer.read_struct(&LISTTOMAP_SCHEMA, (), |_, member, deser| {
         169  +
        deserializer.read_struct(&LISTTOMAP_SCHEMA, &mut |member, deser| {
  170    170   
            match member.member_index() {
  171    171   
                Some(0) => {
  172    172   
                    builder.source = Some(deser.read_string(member)?);
  173    173   
                }
  174    174   
                Some(1) => {
  175    175   
                    builder.key = Some(deser.read_string(member)?);
  176    176   
                }
  177    177   
                Some(2) => {
  178    178   
                    builder.value_key = Some(deser.read_string(member)?);
  179    179   
                }
  180    180   
                Some(3) => {
  181    181   
                    builder.target = Some(deser.read_string(member)?);
  182    182   
                }
  183    183   
                Some(4) => {
  184    184   
                    builder.flatten = Some(deser.read_boolean(member)?);
  185    185   
                }
  186    186   
                Some(5) => {
  187    187   
                    builder.flattened_element = Some(crate::types::FlattenedElement::from(deser.read_string(member)?.as_str()));
  188    188   
                }
  189    189   
                _ => {}
  190    190   
            }
  191    191   
            Ok(())
  192    192   
        })?;
         193  +
        builder.source = builder.source.or(Some(String::new()));
         194  +
        builder.key = builder.key.or(Some(String::new()));
  193    195   
        builder
  194    196   
            .build()
  195    197   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  196    198   
    }
  197    199   
}
         200  +
impl ListToMap {
         201  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         202  +
    pub fn deserialize_with_response(
         203  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         204  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         205  +
        _status: u16,
         206  +
        _body: &[u8],
         207  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         208  +
        Self::deserialize(deserializer)
         209  +
    }
         210  +
}
  198    211   
impl ListToMap {
  199    212   
    /// Creates a new builder-style object to manufacture [`ListToMap`](crate::types::ListToMap).
  200    213   
    pub fn builder() -> crate::types::builders::ListToMapBuilder {
  201    214   
        crate::types::builders::ListToMapBuilder::default()
  202    215   
    }
  203    216   
}
  204    217   
  205    218   
/// A builder for [`ListToMap`](crate::types::ListToMap).
  206    219   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  207    220   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_live_tail_session_log_event.rs

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_live_tail_session_metadata.rs

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_live_tail_session_start.rs

@@ -36,36 +146,146 @@
   56     56   
    "com.amazonaws.cloudwatchlogs",
   57     57   
    "LiveTailSessionStart",
   58     58   
);
   59     59   
static LIVETAILSESSIONSTART_MEMBER_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.cloudwatchlogs#LiveTailSessionStart$requestId",
   62     62   
        "com.amazonaws.cloudwatchlogs",
   63     63   
        "LiveTailSessionStart",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "request_id",
          66  +
    "requestId",
   67     67   
    0,
   68     68   
);
   69     69   
static LIVETAILSESSIONSTART_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.cloudwatchlogs#LiveTailSessionStart$sessionId",
   72     72   
        "com.amazonaws.cloudwatchlogs",
   73     73   
        "LiveTailSessionStart",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "session_id",
          76  +
    "sessionId",
   77     77   
    1,
   78     78   
);
   79     79   
static LIVETAILSESSIONSTART_MEMBER_LOG_GROUP_IDENTIFIERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.cloudwatchlogs#LiveTailSessionStart$logGroupIdentifiers",
   82     82   
        "com.amazonaws.cloudwatchlogs",
   83     83   
        "LiveTailSessionStart",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::List,
   86         -
    "log_group_identifiers",
          86  +
    "logGroupIdentifiers",
   87     87   
    2,
   88     88   
);
   89     89   
static LIVETAILSESSIONSTART_MEMBER_LOG_STREAM_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.cloudwatchlogs#LiveTailSessionStart$logStreamNames",
   92     92   
        "com.amazonaws.cloudwatchlogs",
   93     93   
        "LiveTailSessionStart",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::List,
   96         -
    "log_stream_names",
          96  +
    "logStreamNames",
   97     97   
    3,
   98     98   
);
   99     99   
static LIVETAILSESSIONSTART_MEMBER_LOG_STREAM_NAME_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.cloudwatchlogs#LiveTailSessionStart$logStreamNamePrefixes",
  102    102   
        "com.amazonaws.cloudwatchlogs",
  103    103   
        "LiveTailSessionStart",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::List,
  106         -
    "log_stream_name_prefixes",
         106  +
    "logStreamNamePrefixes",
  107    107   
    4,
  108    108   
);
  109    109   
static LIVETAILSESSIONSTART_MEMBER_LOG_EVENT_FILTER_PATTERN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.cloudwatchlogs#LiveTailSessionStart$logEventFilterPattern",
  112    112   
        "com.amazonaws.cloudwatchlogs",
  113    113   
        "LiveTailSessionStart",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "log_event_filter_pattern",
         116  +
    "logEventFilterPattern",
  117    117   
    5,
  118    118   
);
  119    119   
static LIVETAILSESSIONSTART_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  120    120   
    LIVETAILSESSIONSTART_SCHEMA_ID,
  121    121   
    ::aws_smithy_schema::ShapeType::Structure,
  122    122   
    &[
  123    123   
        &LIVETAILSESSIONSTART_MEMBER_REQUEST_ID,
  124    124   
        &LIVETAILSESSIONSTART_MEMBER_SESSION_ID,
  125    125   
        &LIVETAILSESSIONSTART_MEMBER_LOG_GROUP_IDENTIFIERS,
  126    126   
        &LIVETAILSESSIONSTART_MEMBER_LOG_STREAM_NAMES,
@@ -158,158 +286,267 @@
  178    178   
            )?;
  179    179   
        }
  180    180   
        if let Some(ref val) = self.log_event_filter_pattern {
  181    181   
            ser.write_string(&LIVETAILSESSIONSTART_MEMBER_LOG_EVENT_FILTER_PATTERN, val)?;
  182    182   
        }
  183    183   
        Ok(())
  184    184   
    }
  185    185   
}
  186    186   
impl LiveTailSessionStart {
  187    187   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  188         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  189         -
        deserializer: &mut D,
         188  +
    pub fn deserialize(
         189  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  190    190   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  191    191   
        #[allow(unused_variables, unused_mut)]
  192    192   
        let mut builder = Self::builder();
  193    193   
        #[allow(
  194    194   
            unused_variables,
  195    195   
            unreachable_code,
  196    196   
            clippy::single_match,
  197    197   
            clippy::match_single_binding,
  198    198   
            clippy::diverging_sub_expression
  199    199   
        )]
  200         -
        deserializer.read_struct(&LIVETAILSESSIONSTART_SCHEMA, (), |_, member, deser| {
         200  +
        deserializer.read_struct(&LIVETAILSESSIONSTART_SCHEMA, &mut |member, deser| {
  201    201   
            match member.member_index() {
  202    202   
                Some(0) => {
  203    203   
                    builder.request_id = Some(deser.read_string(member)?);
  204    204   
                }
  205    205   
                Some(1) => {
  206    206   
                    builder.session_id = Some(deser.read_string(member)?);
  207    207   
                }
  208    208   
                Some(2) => {
  209         -
                    builder.log_group_identifiers = Some({
  210         -
                        let container = if let Some(cap) = deser.container_size() {
  211         -
                            Vec::with_capacity(cap)
  212         -
                        } else {
  213         -
                            Vec::new()
  214         -
                        };
  215         -
                        deser.read_list(member, container, |mut list, deser| {
  216         -
                            list.push(deser.read_string(member)?);
  217         -
                            Ok(list)
  218         -
                        })?
  219         -
                    });
         209  +
                    builder.log_group_identifiers = Some(deser.read_string_list(member)?);
  220    210   
                }
  221    211   
                Some(3) => {
  222         -
                    builder.log_stream_names = Some({
  223         -
                        let container = if let Some(cap) = deser.container_size() {
  224         -
                            Vec::with_capacity(cap)
  225         -
                        } else {
  226         -
                            Vec::new()
  227         -
                        };
  228         -
                        deser.read_list(member, container, |mut list, deser| {
  229         -
                            list.push(deser.read_string(member)?);
  230         -
                            Ok(list)
  231         -
                        })?
  232         -
                    });
         212  +
                    builder.log_stream_names = Some(deser.read_string_list(member)?);
  233    213   
                }
  234    214   
                Some(4) => {
  235         -
                    builder.log_stream_name_prefixes = Some({
  236         -
                        let container = if let Some(cap) = deser.container_size() {
  237         -
                            Vec::with_capacity(cap)
  238         -
                        } else {
  239         -
                            Vec::new()
  240         -
                        };
  241         -
                        deser.read_list(member, container, |mut list, deser| {
  242         -
                            list.push(deser.read_string(member)?);
  243         -
                            Ok(list)
  244         -
                        })?
  245         -
                    });
         215  +
                    builder.log_stream_name_prefixes = Some(deser.read_string_list(member)?);
  246    216   
                }
  247    217   
                Some(5) => {
  248    218   
                    builder.log_event_filter_pattern = Some(deser.read_string(member)?);
  249    219   
                }
  250    220   
                _ => {}
  251    221   
            }
  252    222   
            Ok(())
  253    223   
        })?;
  254    224   
        Ok(builder.build())
  255    225   
    }
  256    226   
}
         227  +
impl LiveTailSessionStart {
         228  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         229  +
    pub fn deserialize_with_response(
         230  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         231  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         232  +
        _status: u16,
         233  +
        _body: &[u8],
         234  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         235  +
        Self::deserialize(deserializer)
         236  +
    }
         237  +
}
  257    238   
impl LiveTailSessionStart {
  258    239   
    /// Creates a new builder-style object to manufacture [`LiveTailSessionStart`](crate::types::LiveTailSessionStart).
  259    240   
    pub fn builder() -> crate::types::builders::LiveTailSessionStartBuilder {
  260    241   
        crate::types::builders::LiveTailSessionStartBuilder::default()
  261    242   
    }
  262    243   
}
  263    244   
  264    245   
/// A builder for [`LiveTailSessionStart`](crate::types::LiveTailSessionStart).
  265    246   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  266    247   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_live_tail_session_update.rs

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_log_event.rs

@@ -40,40 +126,137 @@
   60     60   
            ser.write_long(&LOGEVENT_MEMBER_TIMESTAMP, *val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.message {
   63     63   
            ser.write_string(&LOGEVENT_MEMBER_MESSAGE, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl LogEvent {
   69     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   70         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   71         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   72     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        #[allow(unused_variables, unused_mut)]
   74     74   
        let mut builder = Self::builder();
   75     75   
        #[allow(
   76     76   
            unused_variables,
   77     77   
            unreachable_code,
   78     78   
            clippy::single_match,
   79     79   
            clippy::match_single_binding,
   80     80   
            clippy::diverging_sub_expression
   81     81   
        )]
   82         -
        deserializer.read_struct(&LOGEVENT_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&LOGEVENT_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.timestamp = Some(deser.read_long(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.message = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl LogEvent {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   97    108   
impl LogEvent {
   98    109   
    /// Creates a new builder-style object to manufacture [`LogEvent`](crate::types::LogEvent).
   99    110   
    pub fn builder() -> crate::types::builders::LogEventBuilder {
  100    111   
        crate::types::builders::LogEventBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`LogEvent`](crate::types::LogEvent).
  105    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_log_group.rs

@@ -97,97 +253,253 @@
  117    117   
}
  118    118   
static LOGGROUP_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  119    119   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.cloudwatchlogs#LogGroup", "com.amazonaws.cloudwatchlogs", "LogGroup");
  120    120   
static LOGGROUP_MEMBER_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.cloudwatchlogs#LogGroup$logGroupName",
  123    123   
        "com.amazonaws.cloudwatchlogs",
  124    124   
        "LogGroup",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::String,
  127         -
    "log_group_name",
         127  +
    "logGroupName",
  128    128   
    0,
  129    129   
);
  130    130   
static LOGGROUP_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.cloudwatchlogs#LogGroup$creationTime",
  133    133   
        "com.amazonaws.cloudwatchlogs",
  134    134   
        "LogGroup",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::Long,
  137         -
    "creation_time",
         137  +
    "creationTime",
  138    138   
    1,
  139    139   
);
  140    140   
static LOGGROUP_MEMBER_RETENTION_IN_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.cloudwatchlogs#LogGroup$retentionInDays",
  143    143   
        "com.amazonaws.cloudwatchlogs",
  144    144   
        "LogGroup",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::Integer,
  147         -
    "retention_in_days",
         147  +
    "retentionInDays",
  148    148   
    2,
  149    149   
);
  150    150   
static LOGGROUP_MEMBER_METRIC_FILTER_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static(
  152    152   
        "com.amazonaws.cloudwatchlogs#LogGroup$metricFilterCount",
  153    153   
        "com.amazonaws.cloudwatchlogs",
  154    154   
        "LogGroup",
  155    155   
    ),
  156    156   
    ::aws_smithy_schema::ShapeType::Integer,
  157         -
    "metric_filter_count",
         157  +
    "metricFilterCount",
  158    158   
    3,
  159    159   
);
  160    160   
static LOGGROUP_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.cloudwatchlogs#LogGroup$arn", "com.amazonaws.cloudwatchlogs", "LogGroup"),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163    163   
    "arn",
  164    164   
    4,
  165    165   
);
  166    166   
static LOGGROUP_MEMBER_STORED_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.cloudwatchlogs#LogGroup$storedBytes",
  169    169   
        "com.amazonaws.cloudwatchlogs",
  170    170   
        "LogGroup",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::Long,
  173         -
    "stored_bytes",
         173  +
    "storedBytes",
  174    174   
    5,
  175    175   
);
  176    176   
static LOGGROUP_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.cloudwatchlogs#LogGroup$kmsKeyId",
  179    179   
        "com.amazonaws.cloudwatchlogs",
  180    180   
        "LogGroup",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::String,
  183         -
    "kms_key_id",
         183  +
    "kmsKeyId",
  184    184   
    6,
  185    185   
);
  186    186   
static LOGGROUP_MEMBER_DATA_PROTECTION_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  187    187   
    ::aws_smithy_schema::ShapeId::from_static(
  188    188   
        "com.amazonaws.cloudwatchlogs#LogGroup$dataProtectionStatus",
  189    189   
        "com.amazonaws.cloudwatchlogs",
  190    190   
        "LogGroup",
  191    191   
    ),
  192    192   
    ::aws_smithy_schema::ShapeType::String,
  193         -
    "data_protection_status",
         193  +
    "dataProtectionStatus",
  194    194   
    7,
  195    195   
);
  196    196   
static LOGGROUP_MEMBER_INHERITED_PROPERTIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static(
  198    198   
        "com.amazonaws.cloudwatchlogs#LogGroup$inheritedProperties",
  199    199   
        "com.amazonaws.cloudwatchlogs",
  200    200   
        "LogGroup",
  201    201   
    ),
  202    202   
    ::aws_smithy_schema::ShapeType::List,
  203         -
    "inherited_properties",
         203  +
    "inheritedProperties",
  204    204   
    8,
  205    205   
);
  206    206   
static LOGGROUP_MEMBER_LOG_GROUP_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.cloudwatchlogs#LogGroup$logGroupClass",
  209    209   
        "com.amazonaws.cloudwatchlogs",
  210    210   
        "LogGroup",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::String,
  213         -
    "log_group_class",
         213  +
    "logGroupClass",
  214    214   
    9,
  215    215   
);
  216    216   
static LOGGROUP_MEMBER_LOG_GROUP_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.cloudwatchlogs#LogGroup$logGroupArn",
  219    219   
        "com.amazonaws.cloudwatchlogs",
  220    220   
        "LogGroup",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::String,
  223         -
    "log_group_arn",
         223  +
    "logGroupArn",
  224    224   
    10,
  225    225   
);
  226    226   
static LOGGROUP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  227    227   
    LOGGROUP_SCHEMA_ID,
  228    228   
    ::aws_smithy_schema::ShapeType::Structure,
  229    229   
    &[
  230    230   
        &LOGGROUP_MEMBER_LOG_GROUP_NAME,
  231    231   
        &LOGGROUP_MEMBER_CREATION_TIME,
  232    232   
        &LOGGROUP_MEMBER_RETENTION_IN_DAYS,
  233    233   
        &LOGGROUP_MEMBER_METRIC_FILTER_COUNT,
@@ -269,269 +392,400 @@
  289    289   
            ser.write_string(&LOGGROUP_MEMBER_LOG_GROUP_CLASS, val.as_str())?;
  290    290   
        }
  291    291   
        if let Some(ref val) = self.log_group_arn {
  292    292   
            ser.write_string(&LOGGROUP_MEMBER_LOG_GROUP_ARN, val)?;
  293    293   
        }
  294    294   
        Ok(())
  295    295   
    }
  296    296   
}
  297    297   
impl LogGroup {
  298    298   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  299         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  300         -
        deserializer: &mut D,
         299  +
    pub fn deserialize(
         300  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  301    301   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  302    302   
        #[allow(unused_variables, unused_mut)]
  303    303   
        let mut builder = Self::builder();
  304    304   
        #[allow(
  305    305   
            unused_variables,
  306    306   
            unreachable_code,
  307    307   
            clippy::single_match,
  308    308   
            clippy::match_single_binding,
  309    309   
            clippy::diverging_sub_expression
  310    310   
        )]
  311         -
        deserializer.read_struct(&LOGGROUP_SCHEMA, (), |_, member, deser| {
         311  +
        deserializer.read_struct(&LOGGROUP_SCHEMA, &mut |member, deser| {
  312    312   
            match member.member_index() {
  313    313   
                Some(0) => {
  314    314   
                    builder.log_group_name = Some(deser.read_string(member)?);
  315    315   
                }
  316    316   
                Some(1) => {
  317    317   
                    builder.creation_time = Some(deser.read_long(member)?);
  318    318   
                }
  319    319   
                Some(2) => {
  320    320   
                    builder.retention_in_days = Some(deser.read_integer(member)?);
  321    321   
                }
  322    322   
                Some(3) => {
  323    323   
                    builder.metric_filter_count = Some(deser.read_integer(member)?);
  324    324   
                }
  325    325   
                Some(4) => {
  326    326   
                    builder.arn = Some(deser.read_string(member)?);
  327    327   
                }
  328    328   
                Some(5) => {
  329    329   
                    builder.stored_bytes = Some(deser.read_long(member)?);
  330    330   
                }
  331    331   
                Some(6) => {
  332    332   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  333    333   
                }
  334    334   
                Some(7) => {
  335    335   
                    builder.data_protection_status = Some(crate::types::DataProtectionStatus::from(deser.read_string(member)?.as_str()));
  336    336   
                }
  337    337   
                Some(8) => {
  338    338   
                    builder.inherited_properties = Some({
  339         -
                        let container = if let Some(cap) = deser.container_size() {
  340         -
                            Vec::with_capacity(cap)
  341         -
                        } else {
  342         -
                            Vec::new()
  343         -
                        };
  344         -
                        deser.read_list(member, container, |mut list, deser| {
  345         -
                            list.push(crate::types::InheritedProperty::from(deser.read_string(member)?.as_str()));
  346         -
                            Ok(list)
  347         -
                        })?
         339  +
                        let mut container = Vec::new();
         340  +
                        deser.read_list(member, &mut |deser| {
         341  +
                            container.push(crate::types::InheritedProperty::from(deser.read_string(member)?.as_str()));
         342  +
                            Ok(())
         343  +
                        })?;
         344  +
                        container
  348    345   
                    });
  349    346   
                }
  350    347   
                Some(9) => {
  351    348   
                    builder.log_group_class = Some(crate::types::LogGroupClass::from(deser.read_string(member)?.as_str()));
  352    349   
                }
  353    350   
                Some(10) => {
  354    351   
                    builder.log_group_arn = Some(deser.read_string(member)?);
  355    352   
                }
  356    353   
                _ => {}
  357    354   
            }
  358    355   
            Ok(())
  359    356   
        })?;
  360    357   
        Ok(builder.build())
  361    358   
    }
  362    359   
}
         360  +
impl LogGroup {
         361  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         362  +
    pub fn deserialize_with_response(
         363  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         364  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         365  +
        _status: u16,
         366  +
        _body: &[u8],
         367  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         368  +
        Self::deserialize(deserializer)
         369  +
    }
         370  +
}
  363    371   
impl LogGroup {
  364    372   
    /// Creates a new builder-style object to manufacture [`LogGroup`](crate::types::LogGroup).
  365    373   
    pub fn builder() -> crate::types::builders::LogGroupBuilder {
  366    374   
        crate::types::builders::LogGroupBuilder::default()
  367    375   
    }
  368    376   
}
  369    377   
  370    378   
/// A builder for [`LogGroup`](crate::types::LogGroup).
  371    379   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  372    380   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_log_group_field.rs

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_log_group_summary.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_lower_case_string.rs

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_metric_filter.rs

@@ -46,46 +176,176 @@
   66     66   
    "com.amazonaws.cloudwatchlogs",
   67     67   
    "MetricFilter",
   68     68   
);
   69     69   
static METRICFILTER_MEMBER_FILTER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.cloudwatchlogs#MetricFilter$filterName",
   72     72   
        "com.amazonaws.cloudwatchlogs",
   73     73   
        "MetricFilter",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "filter_name",
          76  +
    "filterName",
   77     77   
    0,
   78     78   
);
   79     79   
static METRICFILTER_MEMBER_FILTER_PATTERN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.cloudwatchlogs#MetricFilter$filterPattern",
   82     82   
        "com.amazonaws.cloudwatchlogs",
   83     83   
        "MetricFilter",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "filter_pattern",
          86  +
    "filterPattern",
   87     87   
    1,
   88     88   
);
   89     89   
static METRICFILTER_MEMBER_METRIC_TRANSFORMATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.cloudwatchlogs#MetricFilter$metricTransformations",
   92     92   
        "com.amazonaws.cloudwatchlogs",
   93     93   
        "MetricFilter",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::List,
   96         -
    "metric_transformations",
          96  +
    "metricTransformations",
   97     97   
    2,
   98     98   
);
   99     99   
static METRICFILTER_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.cloudwatchlogs#MetricFilter$creationTime",
  102    102   
        "com.amazonaws.cloudwatchlogs",
  103    103   
        "MetricFilter",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Long,
  106         -
    "creation_time",
         106  +
    "creationTime",
  107    107   
    3,
  108    108   
);
  109    109   
static METRICFILTER_MEMBER_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.cloudwatchlogs#MetricFilter$logGroupName",
  112    112   
        "com.amazonaws.cloudwatchlogs",
  113    113   
        "MetricFilter",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "log_group_name",
         116  +
    "logGroupName",
  117    117   
    4,
  118    118   
);
  119    119   
static METRICFILTER_MEMBER_APPLY_ON_TRANSFORMED_LOGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.cloudwatchlogs#MetricFilter$applyOnTransformedLogs",
  122    122   
        "com.amazonaws.cloudwatchlogs",
  123    123   
        "MetricFilter",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::Boolean,
  126         -
    "apply_on_transformed_logs",
         126  +
    "applyOnTransformedLogs",
  127    127   
    5,
  128    128   
);
  129    129   
static METRICFILTER_MEMBER_FIELD_SELECTION_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.cloudwatchlogs#MetricFilter$fieldSelectionCriteria",
  132    132   
        "com.amazonaws.cloudwatchlogs",
  133    133   
        "MetricFilter",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "field_selection_criteria",
         136  +
    "fieldSelectionCriteria",
  137    137   
    6,
  138    138   
);
  139    139   
static METRICFILTER_MEMBER_EMIT_SYSTEM_FIELD_DIMENSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.cloudwatchlogs#MetricFilter$emitSystemFieldDimensions",
  142    142   
        "com.amazonaws.cloudwatchlogs",
  143    143   
        "MetricFilter",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::List,
  146         -
    "emit_system_field_dimensions",
         146  +
    "emitSystemFieldDimensions",
  147    147   
    7,
  148    148   
);
  149    149   
static METRICFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  150    150   
    METRICFILTER_SCHEMA_ID,
  151    151   
    ::aws_smithy_schema::ShapeType::Structure,
  152    152   
    &[
  153    153   
        &METRICFILTER_MEMBER_FILTER_NAME,
  154    154   
        &METRICFILTER_MEMBER_FILTER_PATTERN,
  155    155   
        &METRICFILTER_MEMBER_METRIC_TRANSFORMATIONS,
  156    156   
        &METRICFILTER_MEMBER_CREATION_TIME,
@@ -189,189 +313,311 @@
  209    209   
                    }
  210    210   
                    Ok(())
  211    211   
                },
  212    212   
            )?;
  213    213   
        }
  214    214   
        Ok(())
  215    215   
    }
  216    216   
}
  217    217   
impl MetricFilter {
  218    218   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  219         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  220         -
        deserializer: &mut D,
         219  +
    pub fn deserialize(
         220  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  221    221   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  222    222   
        #[allow(unused_variables, unused_mut)]
  223    223   
        let mut builder = Self::builder();
  224    224   
        #[allow(
  225    225   
            unused_variables,
  226    226   
            unreachable_code,
  227    227   
            clippy::single_match,
  228    228   
            clippy::match_single_binding,
  229    229   
            clippy::diverging_sub_expression
  230    230   
        )]
  231         -
        deserializer.read_struct(&METRICFILTER_SCHEMA, (), |_, member, deser| {
         231  +
        deserializer.read_struct(&METRICFILTER_SCHEMA, &mut |member, deser| {
  232    232   
            match member.member_index() {
  233    233   
                Some(0) => {
  234    234   
                    builder.filter_name = Some(deser.read_string(member)?);
  235    235   
                }
  236    236   
                Some(1) => {
  237    237   
                    builder.filter_pattern = Some(deser.read_string(member)?);
  238    238   
                }
  239    239   
                Some(2) => {
  240    240   
                    builder.metric_transformations = Some({
  241         -
                        let container = if let Some(cap) = deser.container_size() {
  242         -
                            Vec::with_capacity(cap)
  243         -
                        } else {
  244         -
                            Vec::new()
  245         -
                        };
  246         -
                        deser.read_list(member, container, |mut list, deser| {
  247         -
                            list.push(crate::types::MetricTransformation::deserialize(deser)?);
  248         -
                            Ok(list)
  249         -
                        })?
         241  +
                        let mut container = Vec::new();
         242  +
                        deser.read_list(member, &mut |deser| {
         243  +
                            container.push(crate::types::MetricTransformation::deserialize(deser)?);
         244  +
                            Ok(())
         245  +
                        })?;
         246  +
                        container
  250    247   
                    });
  251    248   
                }
  252    249   
                Some(3) => {
  253    250   
                    builder.creation_time = Some(deser.read_long(member)?);
  254    251   
                }
  255    252   
                Some(4) => {
  256    253   
                    builder.log_group_name = Some(deser.read_string(member)?);
  257    254   
                }
  258    255   
                Some(5) => {
  259    256   
                    builder.apply_on_transformed_logs = Some(deser.read_boolean(member)?);
  260    257   
                }
  261    258   
                Some(6) => {
  262    259   
                    builder.field_selection_criteria = Some(deser.read_string(member)?);
  263    260   
                }
  264    261   
                Some(7) => {
  265         -
                    builder.emit_system_field_dimensions = Some({
  266         -
                        let container = if let Some(cap) = deser.container_size() {
  267         -
                            Vec::with_capacity(cap)
  268         -
                        } else {
  269         -
                            Vec::new()
  270         -
                        };
  271         -
                        deser.read_list(member, container, |mut list, deser| {
  272         -
                            list.push(deser.read_string(member)?);
  273         -
                            Ok(list)
  274         -
                        })?
  275         -
                    });
         262  +
                    builder.emit_system_field_dimensions = Some(deser.read_string_list(member)?);
  276    263   
                }
  277    264   
                _ => {}
  278    265   
            }
  279    266   
            Ok(())
  280    267   
        })?;
  281    268   
        Ok(builder.build())
  282    269   
    }
  283    270   
}
         271  +
impl MetricFilter {
         272  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         273  +
    pub fn deserialize_with_response(
         274  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         275  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         276  +
        _status: u16,
         277  +
        _body: &[u8],
         278  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         279  +
        Self::deserialize(deserializer)
         280  +
    }
         281  +
}
  284    282   
impl MetricFilter {
  285    283   
    /// Creates a new builder-style object to manufacture [`MetricFilter`](crate::types::MetricFilter).
  286    284   
    pub fn builder() -> crate::types::builders::MetricFilterBuilder {
  287    285   
        crate::types::builders::MetricFilterBuilder::default()
  288    286   
    }
  289    287   
}
  290    288   
  291    289   
/// A builder for [`MetricFilter`](crate::types::MetricFilter).
  292    290   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  293    291   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_metric_filter_match_record.rs

@@ -10,10 +175,176 @@
   30     30   
    "com.amazonaws.cloudwatchlogs",
   31     31   
    "MetricFilterMatchRecord",
   32     32   
);
   33     33   
static METRICFILTERMATCHRECORD_MEMBER_EVENT_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.cloudwatchlogs#MetricFilterMatchRecord$eventNumber",
   36     36   
        "com.amazonaws.cloudwatchlogs",
   37     37   
        "MetricFilterMatchRecord",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Long,
   40         -
    "event_number",
          40  +
    "eventNumber",
   41     41   
    0,
   42     42   
);
   43     43   
static METRICFILTERMATCHRECORD_MEMBER_EVENT_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.cloudwatchlogs#MetricFilterMatchRecord$eventMessage",
   46     46   
        "com.amazonaws.cloudwatchlogs",
   47     47   
        "MetricFilterMatchRecord",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "event_message",
          50  +
    "eventMessage",
   51     51   
    1,
   52     52   
);
   53     53   
static METRICFILTERMATCHRECORD_MEMBER_EXTRACTED_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.cloudwatchlogs#MetricFilterMatchRecord$extractedValues",
   56     56   
        "com.amazonaws.cloudwatchlogs",
   57     57   
        "MetricFilterMatchRecord",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Map,
   60         -
    "extracted_values",
          60  +
    "extractedValues",
   61     61   
    2,
   62     62   
);
   63     63   
static METRICFILTERMATCHRECORD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    METRICFILTERMATCHRECORD_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &METRICFILTERMATCHRECORD_MEMBER_EVENT_NUMBER,
   68     68   
        &METRICFILTERMATCHRECORD_MEMBER_EVENT_MESSAGE,
   69     69   
        &METRICFILTERMATCHRECORD_MEMBER_EXTRACTED_VALUES,
   70     70   
    ],
   71     71   
);
   72     72   
impl MetricFilterMatchRecord {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &METRICFILTERMATCHRECORD_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for MetricFilterMatchRecord {
   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   
        {
   83     83   
            let val = &self.event_number;
   84     84   
            ser.write_long(&METRICFILTERMATCHRECORD_MEMBER_EVENT_NUMBER, *val)?;
   85     85   
        }
   86     86   
        if let Some(ref val) = self.event_message {
   87     87   
            ser.write_string(&METRICFILTERMATCHRECORD_MEMBER_EVENT_MESSAGE, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.extracted_values {
   90     90   
            ser.write_map(
   91     91   
                &METRICFILTERMATCHRECORD_MEMBER_EXTRACTED_VALUES,
   92     92   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   93     93   
                    for (key, value) in val {
   94     94   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   95     95   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
   96     96   
                    }
   97     97   
                    Ok(())
   98     98   
                },
   99     99   
            )?;
  100    100   
        }
  101    101   
        Ok(())
  102    102   
    }
  103    103   
}
  104    104   
impl MetricFilterMatchRecord {
  105    105   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  106         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  107         -
        deserializer: &mut D,
         106  +
    pub fn deserialize(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  108    108   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  109    109   
        #[allow(unused_variables, unused_mut)]
  110    110   
        let mut builder = Self::builder();
  111    111   
        #[allow(
  112    112   
            unused_variables,
  113    113   
            unreachable_code,
  114    114   
            clippy::single_match,
  115    115   
            clippy::match_single_binding,
  116    116   
            clippy::diverging_sub_expression
  117    117   
        )]
  118         -
        deserializer.read_struct(&METRICFILTERMATCHRECORD_SCHEMA, (), |_, member, deser| {
         118  +
        deserializer.read_struct(&METRICFILTERMATCHRECORD_SCHEMA, &mut |member, deser| {
  119    119   
            match member.member_index() {
  120    120   
                Some(0) => {
  121    121   
                    builder.event_number = Some(deser.read_long(member)?);
  122    122   
                }
  123    123   
                Some(1) => {
  124    124   
                    builder.event_message = Some(deser.read_string(member)?);
  125    125   
                }
  126    126   
                Some(2) => {
  127         -
                    builder.extracted_values = Some({
  128         -
                        let container = if let Some(cap) = deser.container_size() {
  129         -
                            std::collections::HashMap::with_capacity(cap)
  130         -
                        } else {
  131         -
                            std::collections::HashMap::new()
  132         -
                        };
  133         -
                        deser.read_map(member, container, |mut map, key, deser| {
  134         -
                            map.insert(key, deser.read_string(member)?);
  135         -
                            Ok(map)
  136         -
                        })?
  137         -
                    });
         127  +
                    builder.extracted_values = Some(deser.read_string_string_map(member)?);
  138    128   
                }
  139    129   
                _ => {}
  140    130   
            }
  141    131   
            Ok(())
  142    132   
        })?;
  143    133   
        Ok(builder.build())
  144    134   
    }
  145    135   
}
         136  +
impl MetricFilterMatchRecord {
         137  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         138  +
    pub fn deserialize_with_response(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         140  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         141  +
        _status: u16,
         142  +
        _body: &[u8],
         143  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         144  +
        Self::deserialize(deserializer)
         145  +
    }
         146  +
}
  146    147   
impl MetricFilterMatchRecord {
  147    148   
    /// Creates a new builder-style object to manufacture [`MetricFilterMatchRecord`](crate::types::MetricFilterMatchRecord).
  148    149   
    pub fn builder() -> crate::types::builders::MetricFilterMatchRecordBuilder {
  149    150   
        crate::types::builders::MetricFilterMatchRecordBuilder::default()
  150    151   
    }
  151    152   
}
  152    153   
  153    154   
/// A builder for [`MetricFilterMatchRecord`](crate::types::MetricFilterMatchRecord).
  154    155   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  155    156   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_metric_transformation.rs

@@ -39,39 +129,129 @@
   59     59   
    "com.amazonaws.cloudwatchlogs",
   60     60   
    "MetricTransformation",
   61     61   
);
   62     62   
static METRICTRANSFORMATION_MEMBER_METRIC_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.cloudwatchlogs#MetricTransformation$metricName",
   65     65   
        "com.amazonaws.cloudwatchlogs",
   66     66   
        "MetricTransformation",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "metric_name",
          69  +
    "metricName",
   70     70   
    0,
   71     71   
);
   72     72   
static METRICTRANSFORMATION_MEMBER_METRIC_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.cloudwatchlogs#MetricTransformation$metricNamespace",
   75     75   
        "com.amazonaws.cloudwatchlogs",
   76     76   
        "MetricTransformation",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "metric_namespace",
          79  +
    "metricNamespace",
   80     80   
    1,
   81     81   
);
   82     82   
static METRICTRANSFORMATION_MEMBER_METRIC_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.cloudwatchlogs#MetricTransformation$metricValue",
   85     85   
        "com.amazonaws.cloudwatchlogs",
   86     86   
        "MetricTransformation",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "metric_value",
          89  +
    "metricValue",
   90     90   
    2,
   91     91   
);
   92     92   
static METRICTRANSFORMATION_MEMBER_DEFAULT_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.cloudwatchlogs#MetricTransformation$defaultValue",
   95     95   
        "com.amazonaws.cloudwatchlogs",
   96     96   
        "MetricTransformation",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Double,
   99         -
    "default_value",
          99  +
    "defaultValue",
  100    100   
    3,
  101    101   
);
  102    102   
static METRICTRANSFORMATION_MEMBER_DIMENSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.cloudwatchlogs#MetricTransformation$dimensions",
  105    105   
        "com.amazonaws.cloudwatchlogs",
  106    106   
        "MetricTransformation",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::Map,
  109    109   
    "dimensions",
@@ -149,149 +259,263 @@
  169    169   
            )?;
  170    170   
        }
  171    171   
        if let Some(ref val) = self.unit {
  172    172   
            ser.write_string(&METRICTRANSFORMATION_MEMBER_UNIT, val.as_str())?;
  173    173   
        }
  174    174   
        Ok(())
  175    175   
    }
  176    176   
}
  177    177   
impl MetricTransformation {
  178    178   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  179         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  180         -
        deserializer: &mut D,
         179  +
    pub fn deserialize(
         180  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  181    181   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  182    182   
        #[allow(unused_variables, unused_mut)]
  183    183   
        let mut builder = Self::builder();
  184    184   
        #[allow(
  185    185   
            unused_variables,
  186    186   
            unreachable_code,
  187    187   
            clippy::single_match,
  188    188   
            clippy::match_single_binding,
  189    189   
            clippy::diverging_sub_expression
  190    190   
        )]
  191         -
        deserializer.read_struct(&METRICTRANSFORMATION_SCHEMA, (), |_, member, deser| {
         191  +
        deserializer.read_struct(&METRICTRANSFORMATION_SCHEMA, &mut |member, deser| {
  192    192   
            match member.member_index() {
  193    193   
                Some(0) => {
  194    194   
                    builder.metric_name = Some(deser.read_string(member)?);
  195    195   
                }
  196    196   
                Some(1) => {
  197    197   
                    builder.metric_namespace = Some(deser.read_string(member)?);
  198    198   
                }
  199    199   
                Some(2) => {
  200    200   
                    builder.metric_value = Some(deser.read_string(member)?);
  201    201   
                }
  202    202   
                Some(3) => {
  203    203   
                    builder.default_value = Some(deser.read_double(member)?);
  204    204   
                }
  205    205   
                Some(4) => {
  206         -
                    builder.dimensions = Some({
  207         -
                        let container = if let Some(cap) = deser.container_size() {
  208         -
                            std::collections::HashMap::with_capacity(cap)
  209         -
                        } else {
  210         -
                            std::collections::HashMap::new()
  211         -
                        };
  212         -
                        deser.read_map(member, container, |mut map, key, deser| {
  213         -
                            map.insert(key, deser.read_string(member)?);
  214         -
                            Ok(map)
  215         -
                        })?
  216         -
                    });
         206  +
                    builder.dimensions = Some(deser.read_string_string_map(member)?);
  217    207   
                }
  218    208   
                Some(5) => {
  219    209   
                    builder.unit = Some(crate::types::StandardUnit::from(deser.read_string(member)?.as_str()));
  220    210   
                }
  221    211   
                _ => {}
  222    212   
            }
  223    213   
            Ok(())
  224    214   
        })?;
         215  +
        builder.metric_name = builder.metric_name.or(Some(String::new()));
         216  +
        builder.metric_namespace = builder.metric_namespace.or(Some(String::new()));
         217  +
        builder.metric_value = builder.metric_value.or(Some(String::new()));
  225    218   
        builder
  226    219   
            .build()
  227    220   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  228    221   
    }
  229    222   
}
         223  +
impl MetricTransformation {
         224  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         225  +
    pub fn deserialize_with_response(
         226  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         227  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         228  +
        _status: u16,
         229  +
        _body: &[u8],
         230  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         231  +
        Self::deserialize(deserializer)
         232  +
    }
         233  +
}
  230    234   
impl MetricTransformation {
  231    235   
    /// Creates a new builder-style object to manufacture [`MetricTransformation`](crate::types::MetricTransformation).
  232    236   
    pub fn builder() -> crate::types::builders::MetricTransformationBuilder {
  233    237   
        crate::types::builders::MetricTransformationBuilder::default()
  234    238   
    }
  235    239   
}
  236    240   
  237    241   
/// A builder for [`MetricTransformation`](crate::types::MetricTransformation).
  238    242   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  239    243   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_move_key_entry.rs

@@ -32,32 +162,175 @@
   52     52   
    "target",
   53     53   
    1,
   54     54   
);
   55     55   
static MOVEKEYENTRY_MEMBER_OVERWRITE_IF_EXISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.cloudwatchlogs#MoveKeyEntry$overwriteIfExists",
   58     58   
        "com.amazonaws.cloudwatchlogs",
   59     59   
        "MoveKeyEntry",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Boolean,
   62         -
    "overwrite_if_exists",
          62  +
    "overwriteIfExists",
   63     63   
    2,
   64     64   
);
   65     65   
static MOVEKEYENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    MOVEKEYENTRY_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &MOVEKEYENTRY_MEMBER_SOURCE,
   70     70   
        &MOVEKEYENTRY_MEMBER_TARGET,
   71     71   
        &MOVEKEYENTRY_MEMBER_OVERWRITE_IF_EXISTS,
   72     72   
    ],
   73     73   
);
   74     74   
impl MoveKeyEntry {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MOVEKEYENTRY_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for MoveKeyEntry {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        {
   85     85   
            let val = &self.source;
   86     86   
            ser.write_string(&MOVEKEYENTRY_MEMBER_SOURCE, val)?;
   87     87   
        }
   88     88   
        {
   89     89   
            let val = &self.target;
   90     90   
            ser.write_string(&MOVEKEYENTRY_MEMBER_TARGET, val)?;
   91     91   
        }
   92     92   
        {
   93     93   
            let val = &self.overwrite_if_exists;
   94     94   
            ser.write_boolean(&MOVEKEYENTRY_MEMBER_OVERWRITE_IF_EXISTS, *val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl MoveKeyEntry {
  100    100   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  101         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  102         -
        deserializer: &mut D,
         101  +
    pub fn deserialize(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  103    103   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        #[allow(unused_variables, unused_mut)]
  105    105   
        let mut builder = Self::builder();
  106    106   
        #[allow(
  107    107   
            unused_variables,
  108    108   
            unreachable_code,
  109    109   
            clippy::single_match,
  110    110   
            clippy::match_single_binding,
  111    111   
            clippy::diverging_sub_expression
  112    112   
        )]
  113         -
        deserializer.read_struct(&MOVEKEYENTRY_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&MOVEKEYENTRY_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.source = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.target = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.overwrite_if_exists = Some(deser.read_boolean(member)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
         128  +
        builder.source = builder.source.or(Some(String::new()));
         129  +
        builder.target = builder.target.or(Some(String::new()));
  128    130   
        builder
  129    131   
            .build()
  130    132   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  131    133   
    }
  132    134   
}
         135  +
impl MoveKeyEntry {
         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  +
}
  133    146   
impl MoveKeyEntry {
  134    147   
    /// Creates a new builder-style object to manufacture [`MoveKeyEntry`](crate::types::MoveKeyEntry).
  135    148   
    pub fn builder() -> crate::types::builders::MoveKeyEntryBuilder {
  136    149   
        crate::types::builders::MoveKeyEntryBuilder::default()
  137    150   
    }
  138    151   
}
  139    152   
  140    153   
/// A builder for [`MoveKeyEntry`](crate::types::MoveKeyEntry).
  141    154   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  142    155   
#[non_exhaustive]