AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_provisioned_capacity_response.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_compute_response.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_insights.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_insights_response.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_spatial_coverage.rs

@@ -21,21 +130,141 @@
   41     41   
    "com.amazonaws.timestreamquery",
   42     42   
    "QuerySpatialCoverage",
   43     43   
);
   44     44   
static QUERYSPATIALCOVERAGE_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.timestreamquery#QuerySpatialCoverage$Max",
   47     47   
        "com.amazonaws.timestreamquery",
   48     48   
        "QuerySpatialCoverage",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51         -
    "max",
          51  +
    "Max",
   52     52   
    0,
   53     53   
);
   54     54   
static QUERYSPATIALCOVERAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   55     55   
    QUERYSPATIALCOVERAGE_SCHEMA_ID,
   56     56   
    ::aws_smithy_schema::ShapeType::Structure,
   57     57   
    &[&QUERYSPATIALCOVERAGE_MEMBER_MAX],
   58     58   
);
   59     59   
impl QuerySpatialCoverage {
   60     60   
    /// The schema for this shape.
   61     61   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYSPATIALCOVERAGE_SCHEMA;
   62     62   
}
   63     63   
impl ::aws_smithy_schema::serde::SerializableStruct for QuerySpatialCoverage {
   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.max {
   70     70   
            ser.write_struct(&QUERYSPATIALCOVERAGE_MEMBER_MAX, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl QuerySpatialCoverage {
   76     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     79   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        #[allow(unused_variables, unused_mut)]
   81     81   
        let mut builder = Self::builder();
   82     82   
        #[allow(
   83     83   
            unused_variables,
   84     84   
            unreachable_code,
   85     85   
            clippy::single_match,
   86     86   
            clippy::match_single_binding,
   87     87   
            clippy::diverging_sub_expression
   88     88   
        )]
   89         -
        deserializer.read_struct(&QUERYSPATIALCOVERAGE_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&QUERYSPATIALCOVERAGE_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.max = Some(crate::types::QuerySpatialCoverageMax::deserialize(deser)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl QuerySpatialCoverage {
         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 QuerySpatialCoverage {
  102    113   
    /// Creates a new builder-style object to manufacture [`QuerySpatialCoverage`](crate::types::QuerySpatialCoverage).
  103    114   
    pub fn builder() -> crate::types::builders::QuerySpatialCoverageBuilder {
  104    115   
        crate::types::builders::QuerySpatialCoverageBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`QuerySpatialCoverage`](crate::types::QuerySpatialCoverage).
  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/timestreamquery/src/types/_query_spatial_coverage_max.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_status.rs

@@ -10,10 +158,169 @@
   30     30   
    "com.amazonaws.timestreamquery",
   31     31   
    "QueryStatus",
   32     32   
);
   33     33   
static QUERYSTATUS_MEMBER_PROGRESS_PERCENTAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.timestreamquery#QueryStatus$ProgressPercentage",
   36     36   
        "com.amazonaws.timestreamquery",
   37     37   
        "QueryStatus",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Double,
   40         -
    "progress_percentage",
          40  +
    "ProgressPercentage",
   41     41   
    0,
   42     42   
);
   43     43   
static QUERYSTATUS_MEMBER_CUMULATIVE_BYTES_SCANNED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.timestreamquery#QueryStatus$CumulativeBytesScanned",
   46     46   
        "com.amazonaws.timestreamquery",
   47     47   
        "QueryStatus",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Long,
   50         -
    "cumulative_bytes_scanned",
          50  +
    "CumulativeBytesScanned",
   51     51   
    1,
   52     52   
);
   53     53   
static QUERYSTATUS_MEMBER_CUMULATIVE_BYTES_METERED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.timestreamquery#QueryStatus$CumulativeBytesMetered",
   56     56   
        "com.amazonaws.timestreamquery",
   57     57   
        "QueryStatus",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Long,
   60         -
    "cumulative_bytes_metered",
          60  +
    "CumulativeBytesMetered",
   61     61   
    2,
   62     62   
);
   63     63   
static QUERYSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    QUERYSTATUS_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &QUERYSTATUS_MEMBER_PROGRESS_PERCENTAGE,
   68     68   
        &QUERYSTATUS_MEMBER_CUMULATIVE_BYTES_SCANNED,
   69     69   
        &QUERYSTATUS_MEMBER_CUMULATIVE_BYTES_METERED,
   70     70   
    ],
   71     71   
);
   72     72   
impl QueryStatus {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYSTATUS_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for QueryStatus {
   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.progress_percentage;
   84     84   
            ser.write_double(&QUERYSTATUS_MEMBER_PROGRESS_PERCENTAGE, *val)?;
   85     85   
        }
   86     86   
        {
   87     87   
            let val = &self.cumulative_bytes_scanned;
   88     88   
            ser.write_long(&QUERYSTATUS_MEMBER_CUMULATIVE_BYTES_SCANNED, *val)?;
   89     89   
        }
   90     90   
        {
   91     91   
            let val = &self.cumulative_bytes_metered;
   92     92   
            ser.write_long(&QUERYSTATUS_MEMBER_CUMULATIVE_BYTES_METERED, *val)?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl QueryStatus {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&QUERYSTATUS_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&QUERYSTATUS_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.progress_percentage = Some(deser.read_double(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.cumulative_bytes_scanned = Some(deser.read_long(member)?);
  118    118   
                }
  119    119   
                Some(2) => {
  120    120   
                    builder.cumulative_bytes_metered = Some(deser.read_long(member)?);
  121    121   
                }
  122    122   
                _ => {}
  123    123   
            }
  124    124   
            Ok(())
  125    125   
        })?;
  126    126   
        Ok(builder.build())
  127    127   
    }
  128    128   
}
         129  +
impl QueryStatus {
         130  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         131  +
    pub fn deserialize_with_response(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         133  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         134  +
        _status: u16,
         135  +
        _body: &[u8],
         136  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         137  +
        Self::deserialize(deserializer)
         138  +
    }
         139  +
}
  129    140   
impl QueryStatus {
  130    141   
    /// Creates a new builder-style object to manufacture [`QueryStatus`](crate::types::QueryStatus).
  131    142   
    pub fn builder() -> crate::types::builders::QueryStatusBuilder {
  132    143   
        crate::types::builders::QueryStatusBuilder::default()
  133    144   
    }
  134    145   
}
  135    146   
  136    147   
/// A builder for [`QueryStatus`](crate::types::QueryStatus).
  137    148   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  138    149   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_temporal_range.rs

@@ -10,10 +119,130 @@
   30     30   
    "com.amazonaws.timestreamquery",
   31     31   
    "QueryTemporalRange",
   32     32   
);
   33     33   
static QUERYTEMPORALRANGE_MEMBER_MAX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.timestreamquery#QueryTemporalRange$Max",
   36     36   
        "com.amazonaws.timestreamquery",
   37     37   
        "QueryTemporalRange",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Structure,
   40         -
    "max",
          40  +
    "Max",
   41     41   
    0,
   42     42   
);
   43     43   
static QUERYTEMPORALRANGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   44     44   
    QUERYTEMPORALRANGE_SCHEMA_ID,
   45     45   
    ::aws_smithy_schema::ShapeType::Structure,
   46     46   
    &[&QUERYTEMPORALRANGE_MEMBER_MAX],
   47     47   
);
   48     48   
impl QueryTemporalRange {
   49     49   
    /// The schema for this shape.
   50     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYTEMPORALRANGE_SCHEMA;
   51     51   
}
   52     52   
impl ::aws_smithy_schema::serde::SerializableStruct for QueryTemporalRange {
   53     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   54     54   
    fn serialize_members(
   55     55   
        &self,
   56     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   57     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        if let Some(ref val) = self.max {
   59     59   
            ser.write_struct(&QUERYTEMPORALRANGE_MEMBER_MAX, val)?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl QueryTemporalRange {
   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(&QUERYTEMPORALRANGE_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&QUERYTEMPORALRANGE_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.max = Some(crate::types::QueryTemporalRangeMax::deserialize(deser)?);
   82     82   
                }
   83     83   
                _ => {}
   84     84   
            }
   85     85   
            Ok(())
   86     86   
        })?;
   87     87   
        Ok(builder.build())
   88     88   
    }
   89     89   
}
          90  +
impl QueryTemporalRange {
          91  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          92  +
    pub fn deserialize_with_response(
          93  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          94  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          95  +
        _status: u16,
          96  +
        _body: &[u8],
          97  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          98  +
        Self::deserialize(deserializer)
          99  +
    }
         100  +
}
   90    101   
impl QueryTemporalRange {
   91    102   
    /// Creates a new builder-style object to manufacture [`QueryTemporalRange`](crate::types::QueryTemporalRange).
   92    103   
    pub fn builder() -> crate::types::builders::QueryTemporalRangeBuilder {
   93    104   
        crate::types::builders::QueryTemporalRangeBuilder::default()
   94    105   
    }
   95    106   
}
   96    107   
   97    108   
/// A builder for [`QueryTemporalRange`](crate::types::QueryTemporalRange).
   98    109   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   99    110   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_query_temporal_range_max.rs

@@ -4,4 +130,141 @@
   24     24   
    "com.amazonaws.timestreamquery",
   25     25   
    "QueryTemporalRangeMax",
   26     26   
);
   27     27   
static QUERYTEMPORALRANGEMAX_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.timestreamquery#QueryTemporalRangeMax$Value",
   30     30   
        "com.amazonaws.timestreamquery",
   31     31   
        "QueryTemporalRangeMax",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Long,
   34         -
    "value",
          34  +
    "Value",
   35     35   
    0,
   36     36   
);
   37     37   
static QUERYTEMPORALRANGEMAX_MEMBER_TABLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.timestreamquery#QueryTemporalRangeMax$TableArn",
   40     40   
        "com.amazonaws.timestreamquery",
   41     41   
        "QueryTemporalRangeMax",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "table_arn",
          44  +
    "TableArn",
   45     45   
    1,
   46     46   
);
   47     47   
static QUERYTEMPORALRANGEMAX_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    QUERYTEMPORALRANGEMAX_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&QUERYTEMPORALRANGEMAX_MEMBER_VALUE, &QUERYTEMPORALRANGEMAX_MEMBER_TABLE_ARN],
   51     51   
);
   52     52   
impl QueryTemporalRangeMax {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &QUERYTEMPORALRANGEMAX_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for QueryTemporalRangeMax {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        {
   63     63   
            let val = &self.value;
   64     64   
            ser.write_long(&QUERYTEMPORALRANGEMAX_MEMBER_VALUE, *val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.table_arn {
   67     67   
            ser.write_string(&QUERYTEMPORALRANGEMAX_MEMBER_TABLE_ARN, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl QueryTemporalRangeMax {
   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(&QUERYTEMPORALRANGEMAX_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&QUERYTEMPORALRANGEMAX_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.value = Some(deser.read_long(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.table_arn = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl QueryTemporalRangeMax {
         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 QueryTemporalRangeMax {
  102    113   
    /// Creates a new builder-style object to manufacture [`QueryTemporalRangeMax`](crate::types::QueryTemporalRangeMax).
  103    114   
    pub fn builder() -> crate::types::builders::QueryTemporalRangeMaxBuilder {
  104    115   
        crate::types::builders::QueryTemporalRangeMaxBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`QueryTemporalRangeMax`](crate::types::QueryTemporalRangeMax).
  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/timestreamquery/src/types/_row.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_s3_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_s3_report_location.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_schedule_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_scheduled_query.rs

@@ -48,48 +188,188 @@
   68     68   
    "com.amazonaws.timestreamquery",
   69     69   
    "ScheduledQuery",
   70     70   
);
   71     71   
static SCHEDULEDQUERY_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.timestreamquery#ScheduledQuery$Arn",
   74     74   
        "com.amazonaws.timestreamquery",
   75     75   
        "ScheduledQuery",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "arn",
          78  +
    "Arn",
   79     79   
    0,
   80     80   
);
   81     81   
static SCHEDULEDQUERY_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.timestreamquery#ScheduledQuery$Name",
   84     84   
        "com.amazonaws.timestreamquery",
   85     85   
        "ScheduledQuery",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "name",
          88  +
    "Name",
   89     89   
    1,
   90     90   
);
   91     91   
static SCHEDULEDQUERY_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.timestreamquery#ScheduledQuery$CreationTime",
   94     94   
        "com.amazonaws.timestreamquery",
   95     95   
        "ScheduledQuery",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Timestamp,
   98         -
    "creation_time",
          98  +
    "CreationTime",
   99     99   
    2,
  100    100   
);
  101    101   
static SCHEDULEDQUERY_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.timestreamquery#ScheduledQuery$State",
  104    104   
        "com.amazonaws.timestreamquery",
  105    105   
        "ScheduledQuery",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "state",
         108  +
    "State",
  109    109   
    3,
  110    110   
);
  111    111   
static SCHEDULEDQUERY_MEMBER_PREVIOUS_INVOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.timestreamquery#ScheduledQuery$PreviousInvocationTime",
  114    114   
        "com.amazonaws.timestreamquery",
  115    115   
        "ScheduledQuery",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::Timestamp,
  118         -
    "previous_invocation_time",
         118  +
    "PreviousInvocationTime",
  119    119   
    4,
  120    120   
);
  121    121   
static SCHEDULEDQUERY_MEMBER_NEXT_INVOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.timestreamquery#ScheduledQuery$NextInvocationTime",
  124    124   
        "com.amazonaws.timestreamquery",
  125    125   
        "ScheduledQuery",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::Timestamp,
  128         -
    "next_invocation_time",
         128  +
    "NextInvocationTime",
  129    129   
    5,
  130    130   
);
  131    131   
static SCHEDULEDQUERY_MEMBER_ERROR_REPORT_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.timestreamquery#ScheduledQuery$ErrorReportConfiguration",
  134    134   
        "com.amazonaws.timestreamquery",
  135    135   
        "ScheduledQuery",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::Structure,
  138         -
    "error_report_configuration",
         138  +
    "ErrorReportConfiguration",
  139    139   
    6,
  140    140   
);
  141    141   
static SCHEDULEDQUERY_MEMBER_TARGET_DESTINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.timestreamquery#ScheduledQuery$TargetDestination",
  144    144   
        "com.amazonaws.timestreamquery",
  145    145   
        "ScheduledQuery",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::Structure,
  148         -
    "target_destination",
         148  +
    "TargetDestination",
  149    149   
    7,
  150    150   
);
  151    151   
static SCHEDULEDQUERY_MEMBER_LAST_RUN_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static(
  153    153   
        "com.amazonaws.timestreamquery#ScheduledQuery$LastRunStatus",
  154    154   
        "com.amazonaws.timestreamquery",
  155    155   
        "ScheduledQuery",
  156    156   
    ),
  157    157   
    ::aws_smithy_schema::ShapeType::String,
  158         -
    "last_run_status",
         158  +
    "LastRunStatus",
  159    159   
    8,
  160    160   
);
  161    161   
static SCHEDULEDQUERY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  162    162   
    SCHEDULEDQUERY_SCHEMA_ID,
  163    163   
    ::aws_smithy_schema::ShapeType::Structure,
  164    164   
    &[
  165    165   
        &SCHEDULEDQUERY_MEMBER_ARN,
  166    166   
        &SCHEDULEDQUERY_MEMBER_NAME,
  167    167   
        &SCHEDULEDQUERY_MEMBER_CREATION_TIME,
  168    168   
        &SCHEDULEDQUERY_MEMBER_STATE,
@@ -191,191 +300,313 @@
  211    211   
            ser.write_struct(&SCHEDULEDQUERY_MEMBER_TARGET_DESTINATION, val)?;
  212    212   
        }
  213    213   
        if let Some(ref val) = self.last_run_status {
  214    214   
            ser.write_string(&SCHEDULEDQUERY_MEMBER_LAST_RUN_STATUS, val.as_str())?;
  215    215   
        }
  216    216   
        Ok(())
  217    217   
    }
  218    218   
}
  219    219   
impl ScheduledQuery {
  220    220   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  221         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  222         -
        deserializer: &mut D,
         221  +
    pub fn deserialize(
         222  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  223    223   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  224    224   
        #[allow(unused_variables, unused_mut)]
  225    225   
        let mut builder = Self::builder();
  226    226   
        #[allow(
  227    227   
            unused_variables,
  228    228   
            unreachable_code,
  229    229   
            clippy::single_match,
  230    230   
            clippy::match_single_binding,
  231    231   
            clippy::diverging_sub_expression
  232    232   
        )]
  233         -
        deserializer.read_struct(&SCHEDULEDQUERY_SCHEMA, (), |_, member, deser| {
         233  +
        deserializer.read_struct(&SCHEDULEDQUERY_SCHEMA, &mut |member, deser| {
  234    234   
            match member.member_index() {
  235    235   
                Some(0) => {
  236    236   
                    builder.arn = Some(deser.read_string(member)?);
  237    237   
                }
  238    238   
                Some(1) => {
  239    239   
                    builder.name = Some(deser.read_string(member)?);
  240    240   
                }
  241    241   
                Some(2) => {
  242    242   
                    builder.creation_time = Some(deser.read_timestamp(member)?);
  243    243   
                }
  244    244   
                Some(3) => {
  245    245   
                    builder.state = Some(crate::types::ScheduledQueryState::from(deser.read_string(member)?.as_str()));
  246    246   
                }
  247    247   
                Some(4) => {
  248    248   
                    builder.previous_invocation_time = Some(deser.read_timestamp(member)?);
  249    249   
                }
  250    250   
                Some(5) => {
  251    251   
                    builder.next_invocation_time = Some(deser.read_timestamp(member)?);
  252    252   
                }
  253    253   
                Some(6) => {
  254    254   
                    builder.error_report_configuration = Some(crate::types::ErrorReportConfiguration::deserialize(deser)?);
  255    255   
                }
  256    256   
                Some(7) => {
  257    257   
                    builder.target_destination = Some(crate::types::TargetDestination::deserialize(deser)?);
  258    258   
                }
  259    259   
                Some(8) => {
  260    260   
                    builder.last_run_status = Some(crate::types::ScheduledQueryRunStatus::from(deser.read_string(member)?.as_str()));
  261    261   
                }
  262    262   
                _ => {}
  263    263   
            }
  264    264   
            Ok(())
  265    265   
        })?;
         266  +
        builder.arn = builder.arn.or(Some(String::new()));
         267  +
        builder.name = builder.name.or(Some(String::new()));
  266    268   
        builder
  267    269   
            .build()
  268    270   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  269    271   
    }
  270    272   
}
         273  +
impl ScheduledQuery {
         274  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         275  +
    pub fn deserialize_with_response(
         276  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         277  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         278  +
        _status: u16,
         279  +
        _body: &[u8],
         280  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         281  +
        Self::deserialize(deserializer)
         282  +
    }
         283  +
}
  271    284   
impl ScheduledQuery {
  272    285   
    /// Creates a new builder-style object to manufacture [`ScheduledQuery`](crate::types::ScheduledQuery).
  273    286   
    pub fn builder() -> crate::types::builders::ScheduledQueryBuilder {
  274    287   
        crate::types::builders::ScheduledQueryBuilder::default()
  275    288   
    }
  276    289   
}
  277    290   
  278    291   
/// A builder for [`ScheduledQuery`](crate::types::ScheduledQuery).
  279    292   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  280    293   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamquery/src/types/_scheduled_query_description.rs

@@ -108,108 +308,308 @@
  128    128   
    "com.amazonaws.timestreamquery",
  129    129   
    "ScheduledQueryDescription",
  130    130   
);
  131    131   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$Arn",
  134    134   
        "com.amazonaws.timestreamquery",
  135    135   
        "ScheduledQueryDescription",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::String,
  138         -
    "arn",
         138  +
    "Arn",
  139    139   
    0,
  140    140   
);
  141    141   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  142    142   
    ::aws_smithy_schema::ShapeId::from_static(
  143    143   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$Name",
  144    144   
        "com.amazonaws.timestreamquery",
  145    145   
        "ScheduledQueryDescription",
  146    146   
    ),
  147    147   
    ::aws_smithy_schema::ShapeType::String,
  148         -
    "name",
         148  +
    "Name",
  149    149   
    1,
  150    150   
);
  151    151   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_QUERY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static(
  153    153   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$QueryString",
  154    154   
        "com.amazonaws.timestreamquery",
  155    155   
        "ScheduledQueryDescription",
  156    156   
    ),
  157    157   
    ::aws_smithy_schema::ShapeType::String,
  158         -
    "query_string",
         158  +
    "QueryString",
  159    159   
    2,
  160    160   
);
  161    161   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  162    162   
    ::aws_smithy_schema::ShapeId::from_static(
  163    163   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$CreationTime",
  164    164   
        "com.amazonaws.timestreamquery",
  165    165   
        "ScheduledQueryDescription",
  166    166   
    ),
  167    167   
    ::aws_smithy_schema::ShapeType::Timestamp,
  168         -
    "creation_time",
         168  +
    "CreationTime",
  169    169   
    3,
  170    170   
);
  171    171   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$State",
  174    174   
        "com.amazonaws.timestreamquery",
  175    175   
        "ScheduledQueryDescription",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "state",
         178  +
    "State",
  179    179   
    4,
  180    180   
);
  181    181   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_PREVIOUS_INVOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  182    182   
    ::aws_smithy_schema::ShapeId::from_static(
  183    183   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$PreviousInvocationTime",
  184    184   
        "com.amazonaws.timestreamquery",
  185    185   
        "ScheduledQueryDescription",
  186    186   
    ),
  187    187   
    ::aws_smithy_schema::ShapeType::Timestamp,
  188         -
    "previous_invocation_time",
         188  +
    "PreviousInvocationTime",
  189    189   
    5,
  190    190   
);
  191    191   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_NEXT_INVOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static(
  193    193   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$NextInvocationTime",
  194    194   
        "com.amazonaws.timestreamquery",
  195    195   
        "ScheduledQueryDescription",
  196    196   
    ),
  197    197   
    ::aws_smithy_schema::ShapeType::Timestamp,
  198         -
    "next_invocation_time",
         198  +
    "NextInvocationTime",
  199    199   
    6,
  200    200   
);
  201    201   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_SCHEDULE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  202    202   
    ::aws_smithy_schema::ShapeId::from_static(
  203    203   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$ScheduleConfiguration",
  204    204   
        "com.amazonaws.timestreamquery",
  205    205   
        "ScheduledQueryDescription",
  206    206   
    ),
  207    207   
    ::aws_smithy_schema::ShapeType::Structure,
  208         -
    "schedule_configuration",
         208  +
    "ScheduleConfiguration",
  209    209   
    7,
  210    210   
);
  211    211   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_NOTIFICATION_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  212    212   
    ::aws_smithy_schema::ShapeId::from_static(
  213    213   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$NotificationConfiguration",
  214    214   
        "com.amazonaws.timestreamquery",
  215    215   
        "ScheduledQueryDescription",
  216    216   
    ),
  217    217   
    ::aws_smithy_schema::ShapeType::Structure,
  218         -
    "notification_configuration",
         218  +
    "NotificationConfiguration",
  219    219   
    8,
  220    220   
);
  221    221   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_TARGET_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  222    222   
    ::aws_smithy_schema::ShapeId::from_static(
  223    223   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$TargetConfiguration",
  224    224   
        "com.amazonaws.timestreamquery",
  225    225   
        "ScheduledQueryDescription",
  226    226   
    ),
  227    227   
    ::aws_smithy_schema::ShapeType::Structure,
  228         -
    "target_configuration",
         228  +
    "TargetConfiguration",
  229    229   
    9,
  230    230   
);
  231    231   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_SCHEDULED_QUERY_EXECUTION_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  232    232   
    ::aws_smithy_schema::ShapeId::from_static(
  233    233   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$ScheduledQueryExecutionRoleArn",
  234    234   
        "com.amazonaws.timestreamquery",
  235    235   
        "ScheduledQueryDescription",
  236    236   
    ),
  237    237   
    ::aws_smithy_schema::ShapeType::String,
  238         -
    "scheduled_query_execution_role_arn",
         238  +
    "ScheduledQueryExecutionRoleArn",
  239    239   
    10,
  240    240   
);
  241    241   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  242    242   
    ::aws_smithy_schema::ShapeId::from_static(
  243    243   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$KmsKeyId",
  244    244   
        "com.amazonaws.timestreamquery",
  245    245   
        "ScheduledQueryDescription",
  246    246   
    ),
  247    247   
    ::aws_smithy_schema::ShapeType::String,
  248         -
    "kms_key_id",
         248  +
    "KmsKeyId",
  249    249   
    11,
  250    250   
);
  251    251   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_ERROR_REPORT_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  252    252   
    ::aws_smithy_schema::ShapeId::from_static(
  253    253   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$ErrorReportConfiguration",
  254    254   
        "com.amazonaws.timestreamquery",
  255    255   
        "ScheduledQueryDescription",
  256    256   
    ),
  257    257   
    ::aws_smithy_schema::ShapeType::Structure,
  258         -
    "error_report_configuration",
         258  +
    "ErrorReportConfiguration",
  259    259   
    12,
  260    260   
);
  261    261   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_LAST_RUN_SUMMARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  262    262   
    ::aws_smithy_schema::ShapeId::from_static(
  263    263   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$LastRunSummary",
  264    264   
        "com.amazonaws.timestreamquery",
  265    265   
        "ScheduledQueryDescription",
  266    266   
    ),
  267    267   
    ::aws_smithy_schema::ShapeType::Structure,
  268         -
    "last_run_summary",
         268  +
    "LastRunSummary",
  269    269   
    13,
  270    270   
);
  271    271   
static SCHEDULEDQUERYDESCRIPTION_MEMBER_RECENTLY_FAILED_RUNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  272    272   
    ::aws_smithy_schema::ShapeId::from_static(
  273    273   
        "com.amazonaws.timestreamquery#ScheduledQueryDescription$RecentlyFailedRuns",
  274    274   
        "com.amazonaws.timestreamquery",
  275    275   
        "ScheduledQueryDescription",
  276    276   
    ),
  277    277   
    ::aws_smithy_schema::ShapeType::List,
  278         -
    "recently_failed_runs",
         278  +
    "RecentlyFailedRuns",
  279    279   
    14,
  280    280   
);
  281    281   
static SCHEDULEDQUERYDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  282    282   
    SCHEDULEDQUERYDESCRIPTION_SCHEMA_ID,
  283    283   
    ::aws_smithy_schema::ShapeType::Structure,
  284    284   
    &[
  285    285   
        &SCHEDULEDQUERYDESCRIPTION_MEMBER_ARN,
  286    286   
        &SCHEDULEDQUERYDESCRIPTION_MEMBER_NAME,
  287    287   
        &SCHEDULEDQUERYDESCRIPTION_MEMBER_QUERY_STRING,
  288    288   
        &SCHEDULEDQUERYDESCRIPTION_MEMBER_CREATION_TIME,
@@ -344,344 +481,492 @@
  364    364   
                    }
  365    365   
                    Ok(())
  366    366   
                },
  367    367   
            )?;
  368    368   
        }
  369    369   
        Ok(())
  370    370   
    }
  371    371   
}
  372    372   
impl ScheduledQueryDescription {
  373    373   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  374         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  375         -
        deserializer: &mut D,
         374  +
    pub fn deserialize(
         375  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  376    376   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  377    377   
        #[allow(unused_variables, unused_mut)]
  378    378   
        let mut builder = Self::builder();
  379    379   
        #[allow(
  380    380   
            unused_variables,
  381    381   
            unreachable_code,
  382    382   
            clippy::single_match,
  383    383   
            clippy::match_single_binding,
  384    384   
            clippy::diverging_sub_expression
  385    385   
        )]
  386         -
        deserializer.read_struct(&SCHEDULEDQUERYDESCRIPTION_SCHEMA, (), |_, member, deser| {
         386  +
        deserializer.read_struct(&SCHEDULEDQUERYDESCRIPTION_SCHEMA, &mut |member, deser| {
  387    387   
            match member.member_index() {
  388    388   
                Some(0) => {
  389    389   
                    builder.arn = Some(deser.read_string(member)?);
  390    390   
                }
  391    391   
                Some(1) => {
  392    392   
                    builder.name = Some(deser.read_string(member)?);
  393    393   
                }
  394    394   
                Some(2) => {
  395    395   
                    builder.query_string = Some(deser.read_string(member)?);
  396    396   
                }
  397    397   
                Some(3) => {
  398    398   
                    builder.creation_time = Some(deser.read_timestamp(member)?);
  399    399   
                }
  400    400   
                Some(4) => {
  401    401   
                    builder.state = Some(crate::types::ScheduledQueryState::from(deser.read_string(member)?.as_str()));
  402    402   
                }
  403    403   
                Some(5) => {
  404    404   
                    builder.previous_invocation_time = Some(deser.read_timestamp(member)?);
  405    405   
                }
  406    406   
                Some(6) => {
  407    407   
                    builder.next_invocation_time = Some(deser.read_timestamp(member)?);
  408    408   
                }
  409    409   
                Some(7) => {
  410    410   
                    builder.schedule_configuration = Some(crate::types::ScheduleConfiguration::deserialize(deser)?);
  411    411   
                }
  412    412   
                Some(8) => {
  413    413   
                    builder.notification_configuration = Some(crate::types::NotificationConfiguration::deserialize(deser)?);
  414    414   
                }
  415    415   
                Some(9) => {
  416    416   
                    builder.target_configuration = Some(crate::types::TargetConfiguration::deserialize(deser)?);
  417    417   
                }
  418    418   
                Some(10) => {
  419    419   
                    builder.scheduled_query_execution_role_arn = Some(deser.read_string(member)?);
  420    420   
                }
  421    421   
                Some(11) => {
  422    422   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  423    423   
                }
  424    424   
                Some(12) => {
  425    425   
                    builder.error_report_configuration = Some(crate::types::ErrorReportConfiguration::deserialize(deser)?);
  426    426   
                }
  427    427   
                Some(13) => {
  428    428   
                    builder.last_run_summary = Some(crate::types::ScheduledQueryRunSummary::deserialize(deser)?);
  429    429   
                }
  430    430   
                Some(14) => {
  431    431   
                    builder.recently_failed_runs = Some({
  432         -
                        let container = if let Some(cap) = deser.container_size() {
  433         -
                            Vec::with_capacity(cap)
  434         -
                        } else {
  435         -
                            Vec::new()
  436         -
                        };
  437         -
                        deser.read_list(member, container, |mut list, deser| {
  438         -
                            list.push(crate::types::ScheduledQueryRunSummary::deserialize(deser)?);
  439         -
                            Ok(list)
  440         -
                        })?
         432  +
                        let mut container = Vec::new();
         433  +
                        deser.read_list(member, &mut |deser| {
         434  +
                            container.push(crate::types::ScheduledQueryRunSummary::deserialize(deser)?);
         435  +
                            Ok(())
         436  +
                        })?;
         437  +
                        container
  441    438   
                    });
  442    439   
                }
  443    440   
                _ => {}
  444    441   
            }
  445    442   
            Ok(())
  446    443   
        })?;
         444  +
        builder.arn = builder.arn.or(Some(String::new()));
         445  +
        builder.name = builder.name.or(Some(String::new()));
         446  +
        builder.query_string = builder.query_string.or(Some(String::new()));
  447    447   
        builder
  448    448   
            .build()
  449    449   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  450    450   
    }
  451    451   
}
         452  +
impl ScheduledQueryDescription {
         453  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         454  +
    pub fn deserialize_with_response(
         455  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         456  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         457  +
        _status: u16,
         458  +
        _body: &[u8],
         459  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         460  +
        Self::deserialize(deserializer)
         461  +
    }
         462  +
}
  452    463   
impl ScheduledQueryDescription {
  453    464   
    /// Creates a new builder-style object to manufacture [`ScheduledQueryDescription`](crate::types::ScheduledQueryDescription).
  454    465   
    pub fn builder() -> crate::types::builders::ScheduledQueryDescriptionBuilder {
  455    466   
        crate::types::builders::ScheduledQueryDescriptionBuilder::default()
  456    467   
    }
  457    468   
}
  458    469   
  459    470   
/// A builder for [`ScheduledQueryDescription`](crate::types::ScheduledQueryDescription).
  460    471   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  461    472   
#[non_exhaustive]