AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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

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

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

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

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

@@ -34,34 +247,258 @@
   54     54   
    "com.amazonaws.timestreamquery",
   55     55   
    "ScheduledQueryRunSummary",
   56     56   
);
   57     57   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_INVOCATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$InvocationTime",
   60     60   
        "com.amazonaws.timestreamquery",
   61     61   
        "ScheduledQueryRunSummary",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Timestamp,
   64         -
    "invocation_time",
          64  +
    "InvocationTime",
   65     65   
    0,
   66     66   
);
   67     67   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_TRIGGER_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$TriggerTime",
   70     70   
        "com.amazonaws.timestreamquery",
   71     71   
        "ScheduledQueryRunSummary",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Timestamp,
   74         -
    "trigger_time",
          74  +
    "TriggerTime",
   75     75   
    1,
   76     76   
);
   77     77   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_RUN_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$RunStatus",
   80     80   
        "com.amazonaws.timestreamquery",
   81     81   
        "ScheduledQueryRunSummary",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "run_status",
          84  +
    "RunStatus",
   85     85   
    2,
   86     86   
);
   87     87   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_EXECUTION_STATS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$ExecutionStats",
   90     90   
        "com.amazonaws.timestreamquery",
   91     91   
        "ScheduledQueryRunSummary",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::Structure,
   94         -
    "execution_stats",
          94  +
    "ExecutionStats",
   95     95   
    3,
   96     96   
);
   97     97   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_QUERY_INSIGHTS_RESPONSE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$QueryInsightsResponse",
  100    100   
        "com.amazonaws.timestreamquery",
  101    101   
        "ScheduledQueryRunSummary",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104         -
    "query_insights_response",
         104  +
    "QueryInsightsResponse",
  105    105   
    4,
  106    106   
);
  107    107   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_ERROR_REPORT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$ErrorReportLocation",
  110    110   
        "com.amazonaws.timestreamquery",
  111    111   
        "ScheduledQueryRunSummary",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Structure,
  114         -
    "error_report_location",
         114  +
    "ErrorReportLocation",
  115    115   
    5,
  116    116   
);
  117    117   
static SCHEDULEDQUERYRUNSUMMARY_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.timestreamquery#ScheduledQueryRunSummary$FailureReason",
  120    120   
        "com.amazonaws.timestreamquery",
  121    121   
        "ScheduledQueryRunSummary",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "failure_reason",
         124  +
    "FailureReason",
  125    125   
    6,
  126    126   
);
  127    127   
static SCHEDULEDQUERYRUNSUMMARY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  128    128   
    SCHEDULEDQUERYRUNSUMMARY_SCHEMA_ID,
  129    129   
    ::aws_smithy_schema::ShapeType::Structure,
  130    130   
    &[
  131    131   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_INVOCATION_TIME,
  132    132   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_TRIGGER_TIME,
  133    133   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_RUN_STATUS,
  134    134   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_EXECUTION_STATS,
  135    135   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_QUERY_INSIGHTS_RESPONSE,
  136    136   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_ERROR_REPORT_LOCATION,
  137    137   
        &SCHEDULEDQUERYRUNSUMMARY_MEMBER_FAILURE_REASON,
  138    138   
    ],
  139    139   
);
  140    140   
impl ScheduledQueryRunSummary {
  141    141   
    /// The schema for this shape.
  142    142   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SCHEDULEDQUERYRUNSUMMARY_SCHEMA;
  143    143   
}
  144    144   
impl ::aws_smithy_schema::serde::SerializableStruct for ScheduledQueryRunSummary {
  145    145   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  146    146   
    fn serialize_members(
  147    147   
        &self,
  148    148   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  149    149   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  150    150   
        if let Some(ref val) = self.invocation_time {
  151    151   
            ser.write_timestamp(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_INVOCATION_TIME, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.trigger_time {
  154    154   
            ser.write_timestamp(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_TRIGGER_TIME, val)?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.run_status {
  157    157   
            ser.write_string(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_RUN_STATUS, val.as_str())?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.execution_stats {
  160    160   
            ser.write_struct(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_EXECUTION_STATS, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.query_insights_response {
  163    163   
            ser.write_struct(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_QUERY_INSIGHTS_RESPONSE, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.error_report_location {
  166    166   
            ser.write_struct(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_ERROR_REPORT_LOCATION, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.failure_reason {
  169    169   
            ser.write_string(&SCHEDULEDQUERYRUNSUMMARY_MEMBER_FAILURE_REASON, val)?;
  170    170   
        }
  171    171   
        Ok(())
  172    172   
    }
  173    173   
}
  174    174   
impl ScheduledQueryRunSummary {
  175    175   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  176         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  177         -
        deserializer: &mut D,
         176  +
    pub fn deserialize(
         177  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  178    178   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  179    179   
        #[allow(unused_variables, unused_mut)]
  180    180   
        let mut builder = Self::builder();
  181    181   
        #[allow(
  182    182   
            unused_variables,
  183    183   
            unreachable_code,
  184    184   
            clippy::single_match,
  185    185   
            clippy::match_single_binding,
  186    186   
            clippy::diverging_sub_expression
  187    187   
        )]
  188         -
        deserializer.read_struct(&SCHEDULEDQUERYRUNSUMMARY_SCHEMA, (), |_, member, deser| {
         188  +
        deserializer.read_struct(&SCHEDULEDQUERYRUNSUMMARY_SCHEMA, &mut |member, deser| {
  189    189   
            match member.member_index() {
  190    190   
                Some(0) => {
  191    191   
                    builder.invocation_time = Some(deser.read_timestamp(member)?);
  192    192   
                }
  193    193   
                Some(1) => {
  194    194   
                    builder.trigger_time = Some(deser.read_timestamp(member)?);
  195    195   
                }
  196    196   
                Some(2) => {
  197    197   
                    builder.run_status = Some(crate::types::ScheduledQueryRunStatus::from(deser.read_string(member)?.as_str()));
  198    198   
                }
  199    199   
                Some(3) => {
  200    200   
                    builder.execution_stats = Some(crate::types::ExecutionStats::deserialize(deser)?);
  201    201   
                }
  202    202   
                Some(4) => {
  203    203   
                    builder.query_insights_response = Some(crate::types::ScheduledQueryInsightsResponse::deserialize(deser)?);
  204    204   
                }
  205    205   
                Some(5) => {
  206    206   
                    builder.error_report_location = Some(crate::types::ErrorReportLocation::deserialize(deser)?);
  207    207   
                }
  208    208   
                Some(6) => {
  209    209   
                    builder.failure_reason = Some(deser.read_string(member)?);
  210    210   
                }
  211    211   
                _ => {}
  212    212   
            }
  213    213   
            Ok(())
  214    214   
        })?;
  215    215   
        Ok(builder.build())
  216    216   
    }
  217    217   
}
         218  +
impl ScheduledQueryRunSummary {
         219  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         220  +
    pub fn deserialize_with_response(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         222  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         223  +
        _status: u16,
         224  +
        _body: &[u8],
         225  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         226  +
        Self::deserialize(deserializer)
         227  +
    }
         228  +
}
  218    229   
impl ScheduledQueryRunSummary {
  219    230   
    /// Creates a new builder-style object to manufacture [`ScheduledQueryRunSummary`](crate::types::ScheduledQueryRunSummary).
  220    231   
    pub fn builder() -> crate::types::builders::ScheduledQueryRunSummaryBuilder {
  221    232   
        crate::types::builders::ScheduledQueryRunSummaryBuilder::default()
  222    233   
    }
  223    234   
}
  224    235   
  225    236   
/// A builder for [`ScheduledQueryRunSummary`](crate::types::ScheduledQueryRunSummary).
  226    237   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  227    238   
#[non_exhaustive]

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

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

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

@@ -1,1 +111,123 @@
   19     19   
    "com.amazonaws.timestreamquery",
   20     20   
    "SnsConfiguration",
   21     21   
);
   22     22   
static SNSCONFIGURATION_MEMBER_TOPIC_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.timestreamquery#SnsConfiguration$TopicArn",
   25     25   
        "com.amazonaws.timestreamquery",
   26     26   
        "SnsConfiguration",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "topic_arn",
          29  +
    "TopicArn",
   30     30   
    0,
   31     31   
);
   32     32   
static SNSCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    SNSCONFIGURATION_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&SNSCONFIGURATION_MEMBER_TOPIC_ARN],
   36     36   
);
   37     37   
impl SnsConfiguration {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SNSCONFIGURATION_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for SnsConfiguration {
   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.topic_arn;
   49     49   
            ser.write_string(&SNSCONFIGURATION_MEMBER_TOPIC_ARN, val)?;
   50     50   
        }
   51     51   
        Ok(())
   52     52   
    }
   53     53   
}
   54     54   
impl SnsConfiguration {
   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(&SNSCONFIGURATION_SCHEMA, (), |_, member, deser| {
          68  +
        deserializer.read_struct(&SNSCONFIGURATION_SCHEMA, &mut |member, deser| {
   69     69   
            match member.member_index() {
   70     70   
                Some(0) => {
   71     71   
                    builder.topic_arn = Some(deser.read_string(member)?);
   72     72   
                }
   73     73   
                _ => {}
   74     74   
            }
   75     75   
            Ok(())
   76     76   
        })?;
          77  +
        builder.topic_arn = builder.topic_arn.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 SnsConfiguration {
          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 SnsConfiguration {
   83     95   
    /// Creates a new builder-style object to manufacture [`SnsConfiguration`](crate::types::SnsConfiguration).
   84     96   
    pub fn builder() -> crate::types::builders::SnsConfigurationBuilder {
   85     97   
        crate::types::builders::SnsConfigurationBuilder::default()
   86     98   
    }
   87     99   
}
   88    100   
   89    101   
/// A builder for [`SnsConfiguration`](crate::types::SnsConfiguration).
   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/_tag.rs

@@ -1,1 +124,137 @@
   19     19   
    pub fn value(&self) -> &str {
   20     20   
        use std::ops::Deref;
   21     21   
        self.value.deref()
   22     22   
    }
   23     23   
}
   24     24   
static TAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamquery#Tag", "com.amazonaws.timestreamquery", "Tag");
   26     26   
static TAG_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamquery#Tag$Key", "com.amazonaws.timestreamquery", "Tag"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "key",
          29  +
    "Key",
   30     30   
    0,
   31     31   
);
   32     32   
static TAG_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamquery#Tag$Value", "com.amazonaws.timestreamquery", "Tag"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "value",
          35  +
    "Value",
   36     36   
    1,
   37     37   
);
   38     38   
static TAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    TAG_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&TAG_MEMBER_KEY, &TAG_MEMBER_VALUE],
   42     42   
);
   43     43   
impl Tag {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAG_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for Tag {
   48     48   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   49     49   
    fn serialize_members(
   50     50   
        &self,
   51     51   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   52     52   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        {
   54     54   
            let val = &self.key;
   55     55   
            ser.write_string(&TAG_MEMBER_KEY, val)?;
   56     56   
        }
   57     57   
        {
   58     58   
            let val = &self.value;
   59     59   
            ser.write_string(&TAG_MEMBER_VALUE, val)?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl Tag {
   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(&TAG_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&TAG_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.key = Some(deser.read_string(member)?);
   82     82   
                }
   83     83   
                Some(1) => {
   84     84   
                    builder.value = Some(deser.read_string(member)?);
   85     85   
                }
   86     86   
                _ => {}
   87     87   
            }
   88     88   
            Ok(())
   89     89   
        })?;
          90  +
        builder.key = builder.key.or(Some(String::new()));
          91  +
        builder.value = builder.value.or(Some(String::new()));
   90     92   
        builder
   91     93   
            .build()
   92     94   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   93     95   
    }
   94     96   
}
          97  +
impl Tag {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   95    108   
impl Tag {
   96    109   
    /// Creates a new builder-style object to manufacture [`Tag`](crate::types::Tag).
   97    110   
    pub fn builder() -> crate::types::builders::TagBuilder {
   98    111   
        crate::types::builders::TagBuilder::default()
   99    112   
    }
  100    113   
}
  101    114   
  102    115   
/// A builder for [`Tag`](crate::types::Tag).
  103    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  104    117   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -40,40 +160,160 @@
   60     60   
    "com.amazonaws.timestreamquery",
   61     61   
    "TimestreamConfiguration",
   62     62   
);
   63     63   
static TIMESTREAMCONFIGURATION_MEMBER_DATABASE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$DatabaseName",
   66     66   
        "com.amazonaws.timestreamquery",
   67     67   
        "TimestreamConfiguration",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "database_name",
          70  +
    "DatabaseName",
   71     71   
    0,
   72     72   
);
   73     73   
static TIMESTREAMCONFIGURATION_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$TableName",
   76     76   
        "com.amazonaws.timestreamquery",
   77     77   
        "TimestreamConfiguration",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "table_name",
          80  +
    "TableName",
   81     81   
    1,
   82     82   
);
   83     83   
static TIMESTREAMCONFIGURATION_MEMBER_TIME_COLUMN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$TimeColumn",
   86     86   
        "com.amazonaws.timestreamquery",
   87     87   
        "TimestreamConfiguration",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "time_column",
          90  +
    "TimeColumn",
   91     91   
    2,
   92     92   
);
   93     93   
static TIMESTREAMCONFIGURATION_MEMBER_DIMENSION_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$DimensionMappings",
   96     96   
        "com.amazonaws.timestreamquery",
   97     97   
        "TimestreamConfiguration",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::List,
  100         -
    "dimension_mappings",
         100  +
    "DimensionMappings",
  101    101   
    3,
  102    102   
);
  103    103   
static TIMESTREAMCONFIGURATION_MEMBER_MULTI_MEASURE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$MultiMeasureMappings",
  106    106   
        "com.amazonaws.timestreamquery",
  107    107   
        "TimestreamConfiguration",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::Structure,
  110         -
    "multi_measure_mappings",
         110  +
    "MultiMeasureMappings",
  111    111   
    4,
  112    112   
);
  113    113   
static TIMESTREAMCONFIGURATION_MEMBER_MIXED_MEASURE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$MixedMeasureMappings",
  116    116   
        "com.amazonaws.timestreamquery",
  117    117   
        "TimestreamConfiguration",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::List,
  120         -
    "mixed_measure_mappings",
         120  +
    "MixedMeasureMappings",
  121    121   
    5,
  122    122   
);
  123    123   
static TIMESTREAMCONFIGURATION_MEMBER_MEASURE_NAME_COLUMN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.timestreamquery#TimestreamConfiguration$MeasureNameColumn",
  126    126   
        "com.amazonaws.timestreamquery",
  127    127   
        "TimestreamConfiguration",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "measure_name_column",
         130  +
    "MeasureNameColumn",
  131    131   
    6,
  132    132   
);
  133    133   
static TIMESTREAMCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    TIMESTREAMCONFIGURATION_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &TIMESTREAMCONFIGURATION_MEMBER_DATABASE_NAME,
  138    138   
        &TIMESTREAMCONFIGURATION_MEMBER_TABLE_NAME,
  139    139   
        &TIMESTREAMCONFIGURATION_MEMBER_TIME_COLUMN,
  140    140   
        &TIMESTREAMCONFIGURATION_MEMBER_DIMENSION_MAPPINGS,
@@ -173,173 +296,305 @@
  193    193   
            )?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.measure_name_column {
  196    196   
            ser.write_string(&TIMESTREAMCONFIGURATION_MEMBER_MEASURE_NAME_COLUMN, val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl TimestreamConfiguration {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&TIMESTREAMCONFIGURATION_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&TIMESTREAMCONFIGURATION_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.database_name = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.table_name = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(2) => {
  224    224   
                    builder.time_column = Some(deser.read_string(member)?);
  225    225   
                }
  226    226   
                Some(3) => {
  227    227   
                    builder.dimension_mappings = Some({
  228         -
                        let container = if let Some(cap) = deser.container_size() {
  229         -
                            Vec::with_capacity(cap)
  230         -
                        } else {
  231         -
                            Vec::new()
  232         -
                        };
  233         -
                        deser.read_list(member, container, |mut list, deser| {
  234         -
                            list.push(crate::types::DimensionMapping::deserialize(deser)?);
  235         -
                            Ok(list)
  236         -
                        })?
         228  +
                        let mut container = Vec::new();
         229  +
                        deser.read_list(member, &mut |deser| {
         230  +
                            container.push(crate::types::DimensionMapping::deserialize(deser)?);
         231  +
                            Ok(())
         232  +
                        })?;
         233  +
                        container
  237    234   
                    });
  238    235   
                }
  239    236   
                Some(4) => {
  240    237   
                    builder.multi_measure_mappings = Some(crate::types::MultiMeasureMappings::deserialize(deser)?);
  241    238   
                }
  242    239   
                Some(5) => {
  243    240   
                    builder.mixed_measure_mappings = Some({
  244         -
                        let container = if let Some(cap) = deser.container_size() {
  245         -
                            Vec::with_capacity(cap)
  246         -
                        } else {
  247         -
                            Vec::new()
  248         -
                        };
  249         -
                        deser.read_list(member, container, |mut list, deser| {
  250         -
                            list.push(crate::types::MixedMeasureMapping::deserialize(deser)?);
  251         -
                            Ok(list)
  252         -
                        })?
         241  +
                        let mut container = Vec::new();
         242  +
                        deser.read_list(member, &mut |deser| {
         243  +
                            container.push(crate::types::MixedMeasureMapping::deserialize(deser)?);
         244  +
                            Ok(())
         245  +
                        })?;
         246  +
                        container
  253    247   
                    });
  254    248   
                }
  255    249   
                Some(6) => {
  256    250   
                    builder.measure_name_column = Some(deser.read_string(member)?);
  257    251   
                }
  258    252   
                _ => {}
  259    253   
            }
  260    254   
            Ok(())
  261    255   
        })?;
         256  +
        builder.database_name = builder.database_name.or(Some(String::new()));
         257  +
        builder.table_name = builder.table_name.or(Some(String::new()));
         258  +
        builder.time_column = builder.time_column.or(Some(String::new()));
         259  +
        builder.dimension_mappings = builder.dimension_mappings.or(Some(Vec::new()));
  262    260   
        builder
  263    261   
            .build()
  264    262   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  265    263   
    }
  266    264   
}
         265  +
impl TimestreamConfiguration {
         266  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         267  +
    pub fn deserialize_with_response(
         268  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         269  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         270  +
        _status: u16,
         271  +
        _body: &[u8],
         272  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         273  +
        Self::deserialize(deserializer)
         274  +
    }
         275  +
}
  267    276   
impl TimestreamConfiguration {
  268    277   
    /// Creates a new builder-style object to manufacture [`TimestreamConfiguration`](crate::types::TimestreamConfiguration).
  269    278   
    pub fn builder() -> crate::types::builders::TimestreamConfigurationBuilder {
  270    279   
        crate::types::builders::TimestreamConfigurationBuilder::default()
  271    280   
    }
  272    281   
}
  273    282   
  274    283   
/// A builder for [`TimestreamConfiguration`](crate::types::TimestreamConfiguration).
  275    284   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  276    285   
#[non_exhaustive]

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

@@ -4,4 +129,140 @@
   24     24   
    "com.amazonaws.timestreamquery",
   25     25   
    "TimestreamDestination",
   26     26   
);
   27     27   
static TIMESTREAMDESTINATION_MEMBER_DATABASE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.timestreamquery#TimestreamDestination$DatabaseName",
   30     30   
        "com.amazonaws.timestreamquery",
   31     31   
        "TimestreamDestination",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "database_name",
          34  +
    "DatabaseName",
   35     35   
    0,
   36     36   
);
   37     37   
static TIMESTREAMDESTINATION_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.timestreamquery#TimestreamDestination$TableName",
   40     40   
        "com.amazonaws.timestreamquery",
   41     41   
        "TimestreamDestination",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "table_name",
          44  +
    "TableName",
   45     45   
    1,
   46     46   
);
   47     47   
static TIMESTREAMDESTINATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    TIMESTREAMDESTINATION_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&TIMESTREAMDESTINATION_MEMBER_DATABASE_NAME, &TIMESTREAMDESTINATION_MEMBER_TABLE_NAME],
   51     51   
);
   52     52   
impl TimestreamDestination {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TIMESTREAMDESTINATION_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for TimestreamDestination {
   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.database_name {
   63     63   
            ser.write_string(&TIMESTREAMDESTINATION_MEMBER_DATABASE_NAME, val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.table_name {
   66     66   
            ser.write_string(&TIMESTREAMDESTINATION_MEMBER_TABLE_NAME, val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl TimestreamDestination {
   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(&TIMESTREAMDESTINATION_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&TIMESTREAMDESTINATION_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.database_name = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.table_name = 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 TimestreamDestination {
         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 TimestreamDestination {
  101    112   
    /// Creates a new builder-style object to manufacture [`TimestreamDestination`](crate::types::TimestreamDestination).
  102    113   
    pub fn builder() -> crate::types::builders::TimestreamDestinationBuilder {
  103    114   
        crate::types::builders::TimestreamDestinationBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`TimestreamDestination`](crate::types::TimestreamDestination).
  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/_type_.rs

@@ -11,11 +191,199 @@
   31     31   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.row_column_info.is_none()`.
   32     32   
    pub fn row_column_info(&self) -> &[crate::types::ColumnInfo] {
   33     33   
        self.row_column_info.as_deref().unwrap_or_default()
   34     34   
    }
   35     35   
}
   36     36   
static TYPE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamquery#Type", "com.amazonaws.timestreamquery", "Type");
   38     38   
static TYPE_MEMBER_SCALAR_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamquery#Type$ScalarType", "com.amazonaws.timestreamquery", "Type"),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "scalar_type",
          41  +
    "ScalarType",
   42     42   
    0,
   43     43   
);
   44     44   
static TYPE_MEMBER_ARRAY_COLUMN_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.timestreamquery#Type$ArrayColumnInfo",
   47     47   
        "com.amazonaws.timestreamquery",
   48     48   
        "Type",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51         -
    "array_column_info",
          51  +
    "ArrayColumnInfo",
   52     52   
    1,
   53     53   
);
   54     54   
static TYPE_MEMBER_TIME_SERIES_MEASURE_VALUE_COLUMN_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.timestreamquery#Type$TimeSeriesMeasureValueColumnInfo",
   57     57   
        "com.amazonaws.timestreamquery",
   58     58   
        "Type",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::Structure,
   61         -
    "time_series_measure_value_column_info",
          61  +
    "TimeSeriesMeasureValueColumnInfo",
   62     62   
    2,
   63     63   
);
   64     64   
static TYPE_MEMBER_ROW_COLUMN_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.timestreamquery#Type$RowColumnInfo",
   67     67   
        "com.amazonaws.timestreamquery",
   68     68   
        "Type",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::List,
   71         -
    "row_column_info",
          71  +
    "RowColumnInfo",
   72     72   
    3,
   73     73   
);
   74     74   
static TYPE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   75     75   
    TYPE_SCHEMA_ID,
   76     76   
    ::aws_smithy_schema::ShapeType::Structure,
   77     77   
    &[
   78     78   
        &TYPE_MEMBER_SCALAR_TYPE,
   79     79   
        &TYPE_MEMBER_ARRAY_COLUMN_INFO,
   80     80   
        &TYPE_MEMBER_TIME_SERIES_MEASURE_VALUE_COLUMN_INFO,
   81     81   
        &TYPE_MEMBER_ROW_COLUMN_INFO,
   82     82   
    ],
   83     83   
);
   84     84   
impl Type {
   85     85   
    /// The schema for this shape.
   86     86   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TYPE_SCHEMA;
   87     87   
}
   88     88   
impl ::aws_smithy_schema::serde::SerializableStruct for Type {
   89     89   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   90     90   
    fn serialize_members(
   91     91   
        &self,
   92     92   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   93     93   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   94     94   
        if let Some(ref val) = self.scalar_type {
   95     95   
            ser.write_string(&TYPE_MEMBER_SCALAR_TYPE, val.as_str())?;
   96     96   
        }
   97     97   
        if let Some(ref val) = self.array_column_info {
   98     98   
            ser.write_struct(&TYPE_MEMBER_ARRAY_COLUMN_INFO, val)?;
   99     99   
        }
  100    100   
        if let Some(ref val) = self.time_series_measure_value_column_info {
  101    101   
            ser.write_struct(&TYPE_MEMBER_TIME_SERIES_MEASURE_VALUE_COLUMN_INFO, val)?;
  102    102   
        }
  103    103   
        if let Some(ref val) = self.row_column_info {
  104    104   
            ser.write_list(
  105    105   
                &TYPE_MEMBER_ROW_COLUMN_INFO,
  106    106   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  107    107   
                    for item in val {
  108    108   
                        ser.write_struct(crate::types::ColumnInfo::SCHEMA, item)?;
  109    109   
                    }
  110    110   
                    Ok(())
  111    111   
                },
  112    112   
            )?;
  113    113   
        }
  114    114   
        Ok(())
  115    115   
    }
  116    116   
}
  117    117   
impl Type {
  118    118   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  119         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  120         -
        deserializer: &mut D,
         119  +
    pub fn deserialize(
         120  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  121    121   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  122    122   
        #[allow(unused_variables, unused_mut)]
  123    123   
        let mut builder = Self::builder();
  124    124   
        #[allow(
  125    125   
            unused_variables,
  126    126   
            unreachable_code,
  127    127   
            clippy::single_match,
  128    128   
            clippy::match_single_binding,
  129    129   
            clippy::diverging_sub_expression
  130    130   
        )]
  131         -
        deserializer.read_struct(&TYPE_SCHEMA, (), |_, member, deser| {
         131  +
        deserializer.read_struct(&TYPE_SCHEMA, &mut |member, deser| {
  132    132   
            match member.member_index() {
  133    133   
                Some(0) => {
  134    134   
                    builder.scalar_type = Some(crate::types::ScalarType::from(deser.read_string(member)?.as_str()));
  135    135   
                }
  136    136   
                Some(1) => {
  137    137   
                    builder.array_column_info = Some(crate::types::ColumnInfo::deserialize(deser)?);
  138    138   
                }
  139    139   
                Some(2) => {
  140    140   
                    builder.time_series_measure_value_column_info = Some(crate::types::ColumnInfo::deserialize(deser)?);
  141    141   
                }
  142    142   
                Some(3) => {
  143    143   
                    builder.row_column_info = Some({
  144         -
                        let container = if let Some(cap) = deser.container_size() {
  145         -
                            Vec::with_capacity(cap)
  146         -
                        } else {
  147         -
                            Vec::new()
  148         -
                        };
  149         -
                        deser.read_list(member, container, |mut list, deser| {
  150         -
                            list.push(crate::types::ColumnInfo::deserialize(deser)?);
  151         -
                            Ok(list)
  152         -
                        })?
         144  +
                        let mut container = Vec::new();
         145  +
                        deser.read_list(member, &mut |deser| {
         146  +
                            container.push(crate::types::ColumnInfo::deserialize(deser)?);
         147  +
                            Ok(())
         148  +
                        })?;
         149  +
                        container
  153    150   
                    });
  154    151   
                }
  155    152   
                _ => {}
  156    153   
            }
  157    154   
            Ok(())
  158    155   
        })?;
  159    156   
        Ok(builder.build())
  160    157   
    }
  161    158   
}
         159  +
impl Type {
         160  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         161  +
    pub fn deserialize_with_response(
         162  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         163  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         164  +
        _status: u16,
         165  +
        _body: &[u8],
         166  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         167  +
        Self::deserialize(deserializer)
         168  +
    }
         169  +
}
  162    170   
impl Type {
  163    171   
    /// Creates a new builder-style object to manufacture [`Type`](crate::types::Type).
  164    172   
    pub fn builder() -> crate::types::builders::TypeBuilder {
  165    173   
        crate::types::builders::TypeBuilder::default()
  166    174   
    }
  167    175   
}
  168    176   
  169    177   
/// A builder for [`Type`](crate::types::Type).
  170    178   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  171    179   
#[non_exhaustive]

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

@@ -1,1 +111,122 @@
   13     13   
    "com.amazonaws.timestreamquery",
   14     14   
    "AccessDeniedException",
   15     15   
);
   16     16   
static ACCESSDENIEDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamquery#AccessDeniedException$Message",
   19     19   
        "com.amazonaws.timestreamquery",
   20     20   
        "AccessDeniedException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static ACCESSDENIEDEXCEPTION_TRAITS: std::sync::LazyLock<::aws_smithy_schema::TraitMap> = std::sync::LazyLock::new(|| {
   27     27   
    let mut map = ::aws_smithy_schema::TraitMap::new();
   28     28   
    map.insert(Box::new(::aws_smithy_schema::DocumentTrait::new(
   29     29   
        ::aws_smithy_schema::ShapeId::from_static("aws.protocols#awsQueryError", "aws.protocols", "awsQueryError"),
   30     30   
        ::aws_smithy_types::Document::String("{\"code\":\"AccessDenied\",\"httpResponseCode\":403}".to_string()),
   31     31   
    )));
   32     32   
    map
   33     33   
});
   34     34   
static ACCESSDENIEDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   35     35   
    ACCESSDENIEDEXCEPTION_SCHEMA_ID,
   36     36   
    ::aws_smithy_schema::ShapeType::Structure,
   37     37   
    &[&ACCESSDENIEDEXCEPTION_MEMBER_MESSAGE],
   38     38   
)
   39     39   
.with_traits(&ACCESSDENIEDEXCEPTION_TRAITS);
   40     40   
impl AccessDeniedException {
   41     41   
    /// The schema for this shape.
   42     42   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ACCESSDENIEDEXCEPTION_SCHEMA;
   43     43   
}
   44     44   
impl ::aws_smithy_schema::serde::SerializableStruct for AccessDeniedException {
   45     45   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   46     46   
    fn serialize_members(
   47     47   
        &self,
   48     48   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   49     49   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   50     50   
        if let Some(ref val) = self.message {
   51     51   
            ser.write_string(&ACCESSDENIEDEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl AccessDeniedException {
   57     57   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   58         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   59         -
        deserializer: &mut D,
          58  +
    pub fn deserialize(
          59  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   60     60   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   61     61   
        #[allow(unused_variables, unused_mut)]
   62     62   
        let mut builder = Self::builder();
   63     63   
        #[allow(
   64     64   
            unused_variables,
   65     65   
            unreachable_code,
   66     66   
            clippy::single_match,
   67     67   
            clippy::match_single_binding,
   68     68   
            clippy::diverging_sub_expression
   69     69   
        )]
   70         -
        deserializer.read_struct(&ACCESSDENIEDEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&ACCESSDENIEDEXCEPTION_SCHEMA, &mut |member, deser| {
   71     71   
            match member.member_index() {
   72     72   
                Some(0) => {
   73     73   
                    builder.message = Some(deser.read_string(member)?);
   74     74   
                }
   75     75   
                _ => {}
   76     76   
            }
   77     77   
            Ok(())
   78     78   
        })?;
   79     79   
        Ok(builder.build())
   80     80   
    }
   81     81   
}
          82  +
impl AccessDeniedException {
          83  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          84  +
    pub fn deserialize_with_response(
          85  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          86  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          87  +
        _status: u16,
          88  +
        _body: &[u8],
          89  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          90  +
        Self::deserialize(deserializer)
          91  +
    }
          92  +
}
   82     93   
impl AccessDeniedException {
   83     94   
    /// Returns the error message.
   84     95   
    pub fn message(&self) -> ::std::option::Option<&str> {
   85     96   
        self.message.as_deref()
   86     97   
    }
   87     98   
}
   88     99   
impl ::std::fmt::Display for AccessDeniedException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "AccessDeniedException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.timestreamquery",
   14     14   
    "ConflictException",
   15     15   
);
   16     16   
static CONFLICTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamquery#ConflictException$Message",
   19     19   
        "com.amazonaws.timestreamquery",
   20     20   
        "ConflictException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static CONFLICTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    CONFLICTEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&CONFLICTEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ConflictException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONFLICTEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ConflictException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&CONFLICTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ConflictException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&CONFLICTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&CONFLICTEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl ConflictException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl ConflictException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for ConflictException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ConflictException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.timestreamquery",
   14     14   
    "InternalServerException",
   15     15   
);
   16     16   
static INTERNALSERVEREXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamquery#InternalServerException$Message",
   19     19   
        "com.amazonaws.timestreamquery",
   20     20   
        "InternalServerException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static INTERNALSERVEREXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    INTERNALSERVEREXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&INTERNALSERVEREXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl InternalServerException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTERNALSERVEREXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for InternalServerException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&INTERNALSERVEREXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl InternalServerException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&INTERNALSERVEREXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&INTERNALSERVEREXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl InternalServerException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl InternalServerException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for InternalServerException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "InternalServerException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.timestreamquery",
   14     14   
    "InvalidEndpointException",
   15     15   
);
   16     16   
static INVALIDENDPOINTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamquery#InvalidEndpointException$Message",
   19     19   
        "com.amazonaws.timestreamquery",
   20     20   
        "InvalidEndpointException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static INVALIDENDPOINTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    INVALIDENDPOINTEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&INVALIDENDPOINTEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl InvalidEndpointException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDENDPOINTEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidEndpointException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&INVALIDENDPOINTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl InvalidEndpointException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&INVALIDENDPOINTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&INVALIDENDPOINTEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl InvalidEndpointException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl InvalidEndpointException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for InvalidEndpointException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "InvalidEndpointException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {