AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/serialization_settings.rs

@@ -1,0 +89,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
/*
    3         -
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4         -
 * SPDX-License-Identifier: Apache-2.0
    5         -
 */
    6         -
    7         -
#![allow(dead_code)]
    8         -
    9         -
use aws_smithy_http::header::set_request_header_if_absent;
   10         -
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12         -
   13         -
/// Configuration for how default protocol headers are serialized
   14         -
#[derive(Clone, Debug, Default)]
   15         -
pub(crate) struct HeaderSerializationSettings {
   16         -
    omit_default_content_length: bool,
   17         -
    omit_default_content_type: bool,
   18         -
}
   19         -
   20         -
impl HeaderSerializationSettings {
   21         -
    /// Creates new [`HeaderSerializationSettings`]
   22         -
    pub(crate) fn new() -> Self {
   23         -
        Default::default()
   24         -
    }
   25         -
   26         -
    /// Omit the default `Content-Length` header during serialization
   27         -
    pub(crate) fn omit_default_content_length(self) -> Self {
   28         -
        Self {
   29         -
            omit_default_content_length: true,
   30         -
            ..self
   31         -
        }
   32         -
    }
   33         -
   34         -
    /// Omit the default `Content-Type` header during serialization
   35         -
    pub(crate) fn omit_default_content_type(self) -> Self {
   36         -
        Self {
   37         -
            omit_default_content_type: true,
   38         -
            ..self
   39         -
        }
   40         -
    }
   41         -
   42         -
    /// Returns true if the given default header name should be serialized
   43         -
    fn include_header(&self, header: &HeaderName) -> bool {
   44         -
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45         -
    }
   46         -
   47         -
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(
   49         -
        &self,
   50         -
        mut request: http_1x::request::Builder,
   51         -
        header_name: HeaderName,
   52         -
        value: &str,
   53         -
    ) -> http_1x::request::Builder {
   54         -
        if self.include_header(&header_name) {
   55         -
            request = set_request_header_if_absent(request, header_name, value);
   56         -
        }
   57         -
        request
   58         -
    }
   59         -
}
   60         -
   61         -
impl Storable for HeaderSerializationSettings {
   62         -
    type Storer = StoreReplace<Self>;
   63         -
}
   64         -
   65         -
#[cfg(test)]
   66         -
mod tests {
   67         -
    use super::*;
   68         -
   69         -
    #[test]
   70         -
    fn test_include_header() {
   71         -
        let settings = HeaderSerializationSettings::default();
   72         -
        assert!(settings.include_header(&CONTENT_LENGTH));
   73         -
        assert!(settings.include_header(&CONTENT_TYPE));
   74         -
   75         -
        let settings = HeaderSerializationSettings::default().omit_default_content_length();
   76         -
        assert!(!settings.include_header(&CONTENT_LENGTH));
   77         -
        assert!(settings.include_header(&CONTENT_TYPE));
   78         -
   79         -
        let settings = HeaderSerializationSettings::default().omit_default_content_type();
   80         -
        assert!(settings.include_header(&CONTENT_LENGTH));
   81         -
        assert!(!settings.include_header(&CONTENT_TYPE));
   82         -
   83         -
        let settings = HeaderSerializationSettings::default()
   84         -
            .omit_default_content_type()
   85         -
            .omit_default_content_length();
   86         -
        assert!(!settings.include_header(&CONTENT_LENGTH));
   87         -
        assert!(!settings.include_header(&CONTENT_TYPE));
   88         -
    }
   89         -
}

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_batch_load_progress_report.rs

@@ -28,28 +230,241 @@
   48     48   
    "com.amazonaws.timestreamwrite",
   49     49   
    "BatchLoadProgressReport",
   50     50   
);
   51     51   
static BATCHLOADPROGRESSREPORT_MEMBER_RECORDS_PROCESSED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.timestreamwrite#BatchLoadProgressReport$RecordsProcessed",
   54     54   
        "com.amazonaws.timestreamwrite",
   55     55   
        "BatchLoadProgressReport",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::Long,
   58         -
    "records_processed",
          58  +
    "RecordsProcessed",
   59     59   
    0,
   60     60   
);
   61     61   
static BATCHLOADPROGRESSREPORT_MEMBER_RECORDS_INGESTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.timestreamwrite#BatchLoadProgressReport$RecordsIngested",
   64     64   
        "com.amazonaws.timestreamwrite",
   65     65   
        "BatchLoadProgressReport",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::Long,
   68         -
    "records_ingested",
          68  +
    "RecordsIngested",
   69     69   
    1,
   70     70   
);
   71     71   
static BATCHLOADPROGRESSREPORT_MEMBER_PARSE_FAILURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.timestreamwrite#BatchLoadProgressReport$ParseFailures",
   74     74   
        "com.amazonaws.timestreamwrite",
   75     75   
        "BatchLoadProgressReport",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::Long,
   78         -
    "parse_failures",
          78  +
    "ParseFailures",
   79     79   
    2,
   80     80   
);
   81     81   
static BATCHLOADPROGRESSREPORT_MEMBER_RECORD_INGESTION_FAILURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.timestreamwrite#BatchLoadProgressReport$RecordIngestionFailures",
   84     84   
        "com.amazonaws.timestreamwrite",
   85     85   
        "BatchLoadProgressReport",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Long,
   88         -
    "record_ingestion_failures",
          88  +
    "RecordIngestionFailures",
   89     89   
    3,
   90     90   
);
   91     91   
static BATCHLOADPROGRESSREPORT_MEMBER_FILE_FAILURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.timestreamwrite#BatchLoadProgressReport$FileFailures",
   94     94   
        "com.amazonaws.timestreamwrite",
   95     95   
        "BatchLoadProgressReport",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Long,
   98         -
    "file_failures",
          98  +
    "FileFailures",
   99     99   
    4,
  100    100   
);
  101    101   
static BATCHLOADPROGRESSREPORT_MEMBER_BYTES_METERED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.timestreamwrite#BatchLoadProgressReport$BytesMetered",
  104    104   
        "com.amazonaws.timestreamwrite",
  105    105   
        "BatchLoadProgressReport",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::Long,
  108         -
    "bytes_metered",
         108  +
    "BytesMetered",
  109    109   
    5,
  110    110   
);
  111    111   
static BATCHLOADPROGRESSREPORT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  112    112   
    BATCHLOADPROGRESSREPORT_SCHEMA_ID,
  113    113   
    ::aws_smithy_schema::ShapeType::Structure,
  114    114   
    &[
  115    115   
        &BATCHLOADPROGRESSREPORT_MEMBER_RECORDS_PROCESSED,
  116    116   
        &BATCHLOADPROGRESSREPORT_MEMBER_RECORDS_INGESTED,
  117    117   
        &BATCHLOADPROGRESSREPORT_MEMBER_PARSE_FAILURES,
  118    118   
        &BATCHLOADPROGRESSREPORT_MEMBER_RECORD_INGESTION_FAILURES,
  119    119   
        &BATCHLOADPROGRESSREPORT_MEMBER_FILE_FAILURES,
  120    120   
        &BATCHLOADPROGRESSREPORT_MEMBER_BYTES_METERED,
  121    121   
    ],
  122    122   
);
  123    123   
impl BatchLoadProgressReport {
  124    124   
    /// The schema for this shape.
  125    125   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHLOADPROGRESSREPORT_SCHEMA;
  126    126   
}
  127    127   
impl ::aws_smithy_schema::serde::SerializableStruct for BatchLoadProgressReport {
  128    128   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  129    129   
    fn serialize_members(
  130    130   
        &self,
  131    131   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  132    132   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  133    133   
        {
  134    134   
            let val = &self.records_processed;
  135    135   
            ser.write_long(&BATCHLOADPROGRESSREPORT_MEMBER_RECORDS_PROCESSED, *val)?;
  136    136   
        }
  137    137   
        {
  138    138   
            let val = &self.records_ingested;
  139    139   
            ser.write_long(&BATCHLOADPROGRESSREPORT_MEMBER_RECORDS_INGESTED, *val)?;
  140    140   
        }
  141    141   
        {
  142    142   
            let val = &self.parse_failures;
  143    143   
            ser.write_long(&BATCHLOADPROGRESSREPORT_MEMBER_PARSE_FAILURES, *val)?;
  144    144   
        }
  145    145   
        {
  146    146   
            let val = &self.record_ingestion_failures;
  147    147   
            ser.write_long(&BATCHLOADPROGRESSREPORT_MEMBER_RECORD_INGESTION_FAILURES, *val)?;
  148    148   
        }
  149    149   
        {
  150    150   
            let val = &self.file_failures;
  151    151   
            ser.write_long(&BATCHLOADPROGRESSREPORT_MEMBER_FILE_FAILURES, *val)?;
  152    152   
        }
  153    153   
        {
  154    154   
            let val = &self.bytes_metered;
  155    155   
            ser.write_long(&BATCHLOADPROGRESSREPORT_MEMBER_BYTES_METERED, *val)?;
  156    156   
        }
  157    157   
        Ok(())
  158    158   
    }
  159    159   
}
  160    160   
impl BatchLoadProgressReport {
  161    161   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  162         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  163         -
        deserializer: &mut D,
         162  +
    pub fn deserialize(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  164    164   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  165    165   
        #[allow(unused_variables, unused_mut)]
  166    166   
        let mut builder = Self::builder();
  167    167   
        #[allow(
  168    168   
            unused_variables,
  169    169   
            unreachable_code,
  170    170   
            clippy::single_match,
  171    171   
            clippy::match_single_binding,
  172    172   
            clippy::diverging_sub_expression
  173    173   
        )]
  174         -
        deserializer.read_struct(&BATCHLOADPROGRESSREPORT_SCHEMA, (), |_, member, deser| {
         174  +
        deserializer.read_struct(&BATCHLOADPROGRESSREPORT_SCHEMA, &mut |member, deser| {
  175    175   
            match member.member_index() {
  176    176   
                Some(0) => {
  177    177   
                    builder.records_processed = Some(deser.read_long(member)?);
  178    178   
                }
  179    179   
                Some(1) => {
  180    180   
                    builder.records_ingested = Some(deser.read_long(member)?);
  181    181   
                }
  182    182   
                Some(2) => {
  183    183   
                    builder.parse_failures = Some(deser.read_long(member)?);
  184    184   
                }
  185    185   
                Some(3) => {
  186    186   
                    builder.record_ingestion_failures = Some(deser.read_long(member)?);
  187    187   
                }
  188    188   
                Some(4) => {
  189    189   
                    builder.file_failures = Some(deser.read_long(member)?);
  190    190   
                }
  191    191   
                Some(5) => {
  192    192   
                    builder.bytes_metered = Some(deser.read_long(member)?);
  193    193   
                }
  194    194   
                _ => {}
  195    195   
            }
  196    196   
            Ok(())
  197    197   
        })?;
  198    198   
        Ok(builder.build())
  199    199   
    }
  200    200   
}
         201  +
impl BatchLoadProgressReport {
         202  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        _body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        Self::deserialize(deserializer)
         210  +
    }
         211  +
}
  201    212   
impl BatchLoadProgressReport {
  202    213   
    /// Creates a new builder-style object to manufacture [`BatchLoadProgressReport`](crate::types::BatchLoadProgressReport).
  203    214   
    pub fn builder() -> crate::types::builders::BatchLoadProgressReportBuilder {
  204    215   
        crate::types::builders::BatchLoadProgressReportBuilder::default()
  205    216   
    }
  206    217   
}
  207    218   
  208    219   
/// A builder for [`BatchLoadProgressReport`](crate::types::BatchLoadProgressReport).
  209    220   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  210    221   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_batch_load_task.rs

@@ -34,34 +247,258 @@
   54     54   
    "com.amazonaws.timestreamwrite",
   55     55   
    "BatchLoadTask",
   56     56   
);
   57     57   
static BATCHLOADTASK_MEMBER_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.timestreamwrite#BatchLoadTask$TaskId",
   60     60   
        "com.amazonaws.timestreamwrite",
   61     61   
        "BatchLoadTask",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "task_id",
          64  +
    "TaskId",
   65     65   
    0,
   66     66   
);
   67     67   
static BATCHLOADTASK_MEMBER_TASK_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.timestreamwrite#BatchLoadTask$TaskStatus",
   70     70   
        "com.amazonaws.timestreamwrite",
   71     71   
        "BatchLoadTask",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "task_status",
          74  +
    "TaskStatus",
   75     75   
    1,
   76     76   
);
   77     77   
static BATCHLOADTASK_MEMBER_DATABASE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.timestreamwrite#BatchLoadTask$DatabaseName",
   80     80   
        "com.amazonaws.timestreamwrite",
   81     81   
        "BatchLoadTask",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "database_name",
          84  +
    "DatabaseName",
   85     85   
    2,
   86     86   
);
   87     87   
static BATCHLOADTASK_MEMBER_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.timestreamwrite#BatchLoadTask$TableName",
   90     90   
        "com.amazonaws.timestreamwrite",
   91     91   
        "BatchLoadTask",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "table_name",
          94  +
    "TableName",
   95     95   
    3,
   96     96   
);
   97     97   
static BATCHLOADTASK_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.timestreamwrite#BatchLoadTask$CreationTime",
  100    100   
        "com.amazonaws.timestreamwrite",
  101    101   
        "BatchLoadTask",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Timestamp,
  104         -
    "creation_time",
         104  +
    "CreationTime",
  105    105   
    4,
  106    106   
);
  107    107   
static BATCHLOADTASK_MEMBER_LAST_UPDATED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.timestreamwrite#BatchLoadTask$LastUpdatedTime",
  110    110   
        "com.amazonaws.timestreamwrite",
  111    111   
        "BatchLoadTask",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Timestamp,
  114         -
    "last_updated_time",
         114  +
    "LastUpdatedTime",
  115    115   
    5,
  116    116   
);
  117    117   
static BATCHLOADTASK_MEMBER_RESUMABLE_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.timestreamwrite#BatchLoadTask$ResumableUntil",
  120    120   
        "com.amazonaws.timestreamwrite",
  121    121   
        "BatchLoadTask",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::Timestamp,
  124         -
    "resumable_until",
         124  +
    "ResumableUntil",
  125    125   
    6,
  126    126   
);
  127    127   
static BATCHLOADTASK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  128    128   
    BATCHLOADTASK_SCHEMA_ID,
  129    129   
    ::aws_smithy_schema::ShapeType::Structure,
  130    130   
    &[
  131    131   
        &BATCHLOADTASK_MEMBER_TASK_ID,
  132    132   
        &BATCHLOADTASK_MEMBER_TASK_STATUS,
  133    133   
        &BATCHLOADTASK_MEMBER_DATABASE_NAME,
  134    134   
        &BATCHLOADTASK_MEMBER_TABLE_NAME,
  135    135   
        &BATCHLOADTASK_MEMBER_CREATION_TIME,
  136    136   
        &BATCHLOADTASK_MEMBER_LAST_UPDATED_TIME,
  137    137   
        &BATCHLOADTASK_MEMBER_RESUMABLE_UNTIL,
  138    138   
    ],
  139    139   
);
  140    140   
impl BatchLoadTask {
  141    141   
    /// The schema for this shape.
  142    142   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHLOADTASK_SCHEMA;
  143    143   
}
  144    144   
impl ::aws_smithy_schema::serde::SerializableStruct for BatchLoadTask {
  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.task_id {
  151    151   
            ser.write_string(&BATCHLOADTASK_MEMBER_TASK_ID, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.task_status {
  154    154   
            ser.write_string(&BATCHLOADTASK_MEMBER_TASK_STATUS, val.as_str())?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.database_name {
  157    157   
            ser.write_string(&BATCHLOADTASK_MEMBER_DATABASE_NAME, val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.table_name {
  160    160   
            ser.write_string(&BATCHLOADTASK_MEMBER_TABLE_NAME, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.creation_time {
  163    163   
            ser.write_timestamp(&BATCHLOADTASK_MEMBER_CREATION_TIME, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.last_updated_time {
  166    166   
            ser.write_timestamp(&BATCHLOADTASK_MEMBER_LAST_UPDATED_TIME, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.resumable_until {
  169    169   
            ser.write_timestamp(&BATCHLOADTASK_MEMBER_RESUMABLE_UNTIL, val)?;
  170    170   
        }
  171    171   
        Ok(())
  172    172   
    }
  173    173   
}
  174    174   
impl BatchLoadTask {
  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(&BATCHLOADTASK_SCHEMA, (), |_, member, deser| {
         188  +
        deserializer.read_struct(&BATCHLOADTASK_SCHEMA, &mut |member, deser| {
  189    189   
            match member.member_index() {
  190    190   
                Some(0) => {
  191    191   
                    builder.task_id = Some(deser.read_string(member)?);
  192    192   
                }
  193    193   
                Some(1) => {
  194    194   
                    builder.task_status = Some(crate::types::BatchLoadStatus::from(deser.read_string(member)?.as_str()));
  195    195   
                }
  196    196   
                Some(2) => {
  197    197   
                    builder.database_name = Some(deser.read_string(member)?);
  198    198   
                }
  199    199   
                Some(3) => {
  200    200   
                    builder.table_name = Some(deser.read_string(member)?);
  201    201   
                }
  202    202   
                Some(4) => {
  203    203   
                    builder.creation_time = Some(deser.read_timestamp(member)?);
  204    204   
                }
  205    205   
                Some(5) => {
  206    206   
                    builder.last_updated_time = Some(deser.read_timestamp(member)?);
  207    207   
                }
  208    208   
                Some(6) => {
  209    209   
                    builder.resumable_until = Some(deser.read_timestamp(member)?);
  210    210   
                }
  211    211   
                _ => {}
  212    212   
            }
  213    213   
            Ok(())
  214    214   
        })?;
  215    215   
        Ok(builder.build())
  216    216   
    }
  217    217   
}
         218  +
impl BatchLoadTask {
         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 BatchLoadTask {
  219    230   
    /// Creates a new builder-style object to manufacture [`BatchLoadTask`](crate::types::BatchLoadTask).
  220    231   
    pub fn builder() -> crate::types::builders::BatchLoadTaskBuilder {
  221    232   
        crate::types::builders::BatchLoadTaskBuilder::default()
  222    233   
    }
  223    234   
}
  224    235   
  225    236   
/// A builder for [`BatchLoadTask`](crate::types::BatchLoadTask).
  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/timestreamwrite/src/types/_batch_load_task_description.rs

@@ -70,70 +250,250 @@
   90     90   
    "com.amazonaws.timestreamwrite",
   91     91   
    "BatchLoadTaskDescription",
   92     92   
);
   93     93   
static BATCHLOADTASKDESCRIPTION_MEMBER_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$TaskId",
   96     96   
        "com.amazonaws.timestreamwrite",
   97     97   
        "BatchLoadTaskDescription",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "task_id",
         100  +
    "TaskId",
  101    101   
    0,
  102    102   
);
  103    103   
static BATCHLOADTASKDESCRIPTION_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$ErrorMessage",
  106    106   
        "com.amazonaws.timestreamwrite",
  107    107   
        "BatchLoadTaskDescription",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "error_message",
         110  +
    "ErrorMessage",
  111    111   
    1,
  112    112   
);
  113    113   
static BATCHLOADTASKDESCRIPTION_MEMBER_DATA_SOURCE_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$DataSourceConfiguration",
  116    116   
        "com.amazonaws.timestreamwrite",
  117    117   
        "BatchLoadTaskDescription",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120         -
    "data_source_configuration",
         120  +
    "DataSourceConfiguration",
  121    121   
    2,
  122    122   
);
  123    123   
static BATCHLOADTASKDESCRIPTION_MEMBER_PROGRESS_REPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$ProgressReport",
  126    126   
        "com.amazonaws.timestreamwrite",
  127    127   
        "BatchLoadTaskDescription",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::Structure,
  130         -
    "progress_report",
         130  +
    "ProgressReport",
  131    131   
    3,
  132    132   
);
  133    133   
static BATCHLOADTASKDESCRIPTION_MEMBER_REPORT_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static(
  135    135   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$ReportConfiguration",
  136    136   
        "com.amazonaws.timestreamwrite",
  137    137   
        "BatchLoadTaskDescription",
  138    138   
    ),
  139    139   
    ::aws_smithy_schema::ShapeType::Structure,
  140         -
    "report_configuration",
         140  +
    "ReportConfiguration",
  141    141   
    4,
  142    142   
);
  143    143   
static BATCHLOADTASKDESCRIPTION_MEMBER_DATA_MODEL_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static(
  145    145   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$DataModelConfiguration",
  146    146   
        "com.amazonaws.timestreamwrite",
  147    147   
        "BatchLoadTaskDescription",
  148    148   
    ),
  149    149   
    ::aws_smithy_schema::ShapeType::Structure,
  150         -
    "data_model_configuration",
         150  +
    "DataModelConfiguration",
  151    151   
    5,
  152    152   
);
  153    153   
static BATCHLOADTASKDESCRIPTION_MEMBER_TARGET_DATABASE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  154    154   
    ::aws_smithy_schema::ShapeId::from_static(
  155    155   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$TargetDatabaseName",
  156    156   
        "com.amazonaws.timestreamwrite",
  157    157   
        "BatchLoadTaskDescription",
  158    158   
    ),
  159    159   
    ::aws_smithy_schema::ShapeType::String,
  160         -
    "target_database_name",
         160  +
    "TargetDatabaseName",
  161    161   
    6,
  162    162   
);
  163    163   
static BATCHLOADTASKDESCRIPTION_MEMBER_TARGET_TABLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static(
  165    165   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$TargetTableName",
  166    166   
        "com.amazonaws.timestreamwrite",
  167    167   
        "BatchLoadTaskDescription",
  168    168   
    ),
  169    169   
    ::aws_smithy_schema::ShapeType::String,
  170         -
    "target_table_name",
         170  +
    "TargetTableName",
  171    171   
    7,
  172    172   
);
  173    173   
static BATCHLOADTASKDESCRIPTION_MEMBER_TASK_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static(
  175    175   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$TaskStatus",
  176    176   
        "com.amazonaws.timestreamwrite",
  177    177   
        "BatchLoadTaskDescription",
  178    178   
    ),
  179    179   
    ::aws_smithy_schema::ShapeType::String,
  180         -
    "task_status",
         180  +
    "TaskStatus",
  181    181   
    8,
  182    182   
);
  183    183   
static BATCHLOADTASKDESCRIPTION_MEMBER_RECORD_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  184    184   
    ::aws_smithy_schema::ShapeId::from_static(
  185    185   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$RecordVersion",
  186    186   
        "com.amazonaws.timestreamwrite",
  187    187   
        "BatchLoadTaskDescription",
  188    188   
    ),
  189    189   
    ::aws_smithy_schema::ShapeType::Long,
  190         -
    "record_version",
         190  +
    "RecordVersion",
  191    191   
    9,
  192    192   
);
  193    193   
static BATCHLOADTASKDESCRIPTION_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  194    194   
    ::aws_smithy_schema::ShapeId::from_static(
  195    195   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$CreationTime",
  196    196   
        "com.amazonaws.timestreamwrite",
  197    197   
        "BatchLoadTaskDescription",
  198    198   
    ),
  199    199   
    ::aws_smithy_schema::ShapeType::Timestamp,
  200         -
    "creation_time",
         200  +
    "CreationTime",
  201    201   
    10,
  202    202   
);
  203    203   
static BATCHLOADTASKDESCRIPTION_MEMBER_LAST_UPDATED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  204    204   
    ::aws_smithy_schema::ShapeId::from_static(
  205    205   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$LastUpdatedTime",
  206    206   
        "com.amazonaws.timestreamwrite",
  207    207   
        "BatchLoadTaskDescription",
  208    208   
    ),
  209    209   
    ::aws_smithy_schema::ShapeType::Timestamp,
  210         -
    "last_updated_time",
         210  +
    "LastUpdatedTime",
  211    211   
    11,
  212    212   
);
  213    213   
static BATCHLOADTASKDESCRIPTION_MEMBER_RESUMABLE_UNTIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  214    214   
    ::aws_smithy_schema::ShapeId::from_static(
  215    215   
        "com.amazonaws.timestreamwrite#BatchLoadTaskDescription$ResumableUntil",
  216    216   
        "com.amazonaws.timestreamwrite",
  217    217   
        "BatchLoadTaskDescription",
  218    218   
    ),
  219    219   
    ::aws_smithy_schema::ShapeType::Timestamp,
  220         -
    "resumable_until",
         220  +
    "ResumableUntil",
  221    221   
    12,
  222    222   
);
  223    223   
static BATCHLOADTASKDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  224    224   
    BATCHLOADTASKDESCRIPTION_SCHEMA_ID,
  225    225   
    ::aws_smithy_schema::ShapeType::Structure,
  226    226   
    &[
  227    227   
        &BATCHLOADTASKDESCRIPTION_MEMBER_TASK_ID,
  228    228   
        &BATCHLOADTASKDESCRIPTION_MEMBER_ERROR_MESSAGE,
  229    229   
        &BATCHLOADTASKDESCRIPTION_MEMBER_DATA_SOURCE_CONFIGURATION,
  230    230   
        &BATCHLOADTASKDESCRIPTION_MEMBER_PROGRESS_REPORT,
@@ -267,267 +386,397 @@
  287    287   
            ser.write_timestamp(&BATCHLOADTASKDESCRIPTION_MEMBER_LAST_UPDATED_TIME, val)?;
  288    288   
        }
  289    289   
        if let Some(ref val) = self.resumable_until {
  290    290   
            ser.write_timestamp(&BATCHLOADTASKDESCRIPTION_MEMBER_RESUMABLE_UNTIL, val)?;
  291    291   
        }
  292    292   
        Ok(())
  293    293   
    }
  294    294   
}
  295    295   
impl BatchLoadTaskDescription {
  296    296   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  297         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  298         -
        deserializer: &mut D,
         297  +
    pub fn deserialize(
         298  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  299    299   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  300    300   
        #[allow(unused_variables, unused_mut)]
  301    301   
        let mut builder = Self::builder();
  302    302   
        #[allow(
  303    303   
            unused_variables,
  304    304   
            unreachable_code,
  305    305   
            clippy::single_match,
  306    306   
            clippy::match_single_binding,
  307    307   
            clippy::diverging_sub_expression
  308    308   
        )]
  309         -
        deserializer.read_struct(&BATCHLOADTASKDESCRIPTION_SCHEMA, (), |_, member, deser| {
         309  +
        deserializer.read_struct(&BATCHLOADTASKDESCRIPTION_SCHEMA, &mut |member, deser| {
  310    310   
            match member.member_index() {
  311    311   
                Some(0) => {
  312    312   
                    builder.task_id = Some(deser.read_string(member)?);
  313    313   
                }
  314    314   
                Some(1) => {
  315    315   
                    builder.error_message = Some(deser.read_string(member)?);
  316    316   
                }
  317    317   
                Some(2) => {
  318    318   
                    builder.data_source_configuration = Some(crate::types::DataSourceConfiguration::deserialize(deser)?);
  319    319   
                }
  320    320   
                Some(3) => {
  321    321   
                    builder.progress_report = Some(crate::types::BatchLoadProgressReport::deserialize(deser)?);
  322    322   
                }
  323    323   
                Some(4) => {
  324    324   
                    builder.report_configuration = Some(crate::types::ReportConfiguration::deserialize(deser)?);
  325    325   
                }
  326    326   
                Some(5) => {
  327    327   
                    builder.data_model_configuration = Some(crate::types::DataModelConfiguration::deserialize(deser)?);
  328    328   
                }
  329    329   
                Some(6) => {
  330    330   
                    builder.target_database_name = Some(deser.read_string(member)?);
  331    331   
                }
  332    332   
                Some(7) => {
  333    333   
                    builder.target_table_name = Some(deser.read_string(member)?);
  334    334   
                }
  335    335   
                Some(8) => {
  336    336   
                    builder.task_status = Some(crate::types::BatchLoadStatus::from(deser.read_string(member)?.as_str()));
  337    337   
                }
  338    338   
                Some(9) => {
  339    339   
                    builder.record_version = Some(deser.read_long(member)?);
  340    340   
                }
  341    341   
                Some(10) => {
  342    342   
                    builder.creation_time = Some(deser.read_timestamp(member)?);
  343    343   
                }
  344    344   
                Some(11) => {
  345    345   
                    builder.last_updated_time = Some(deser.read_timestamp(member)?);
  346    346   
                }
  347    347   
                Some(12) => {
  348    348   
                    builder.resumable_until = Some(deser.read_timestamp(member)?);
  349    349   
                }
  350    350   
                _ => {}
  351    351   
            }
  352    352   
            Ok(())
  353    353   
        })?;
  354    354   
        Ok(builder.build())
  355    355   
    }
  356    356   
}
         357  +
impl BatchLoadTaskDescription {
         358  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         359  +
    pub fn deserialize_with_response(
         360  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         361  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         362  +
        _status: u16,
         363  +
        _body: &[u8],
         364  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         365  +
        Self::deserialize(deserializer)
         366  +
    }
         367  +
}
  357    368   
impl BatchLoadTaskDescription {
  358    369   
    /// Creates a new builder-style object to manufacture [`BatchLoadTaskDescription`](crate::types::BatchLoadTaskDescription).
  359    370   
    pub fn builder() -> crate::types::builders::BatchLoadTaskDescriptionBuilder {
  360    371   
        crate::types::builders::BatchLoadTaskDescriptionBuilder::default()
  361    372   
    }
  362    373   
}
  363    374   
  364    375   
/// A builder for [`BatchLoadTaskDescription`](crate::types::BatchLoadTaskDescription).
  365    376   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  366    377   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_csv_configuration.rs

@@ -22,22 +201,212 @@
   42     42   
    "com.amazonaws.timestreamwrite",
   43     43   
    "CsvConfiguration",
   44     44   
);
   45     45   
static CSVCONFIGURATION_MEMBER_COLUMN_SEPARATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.timestreamwrite#CsvConfiguration$ColumnSeparator",
   48     48   
        "com.amazonaws.timestreamwrite",
   49     49   
        "CsvConfiguration",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "column_separator",
          52  +
    "ColumnSeparator",
   53     53   
    0,
   54     54   
);
   55     55   
static CSVCONFIGURATION_MEMBER_ESCAPE_CHAR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.timestreamwrite#CsvConfiguration$EscapeChar",
   58     58   
        "com.amazonaws.timestreamwrite",
   59     59   
        "CsvConfiguration",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "escape_char",
          62  +
    "EscapeChar",
   63     63   
    1,
   64     64   
);
   65     65   
static CSVCONFIGURATION_MEMBER_QUOTE_CHAR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.timestreamwrite#CsvConfiguration$QuoteChar",
   68     68   
        "com.amazonaws.timestreamwrite",
   69     69   
        "CsvConfiguration",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "quote_char",
          72  +
    "QuoteChar",
   73     73   
    2,
   74     74   
);
   75     75   
static CSVCONFIGURATION_MEMBER_NULL_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.timestreamwrite#CsvConfiguration$NullValue",
   78     78   
        "com.amazonaws.timestreamwrite",
   79     79   
        "CsvConfiguration",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "null_value",
          82  +
    "NullValue",
   83     83   
    3,
   84     84   
);
   85     85   
static CSVCONFIGURATION_MEMBER_TRIM_WHITE_SPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.timestreamwrite#CsvConfiguration$TrimWhiteSpace",
   88     88   
        "com.amazonaws.timestreamwrite",
   89     89   
        "CsvConfiguration",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Boolean,
   92         -
    "trim_white_space",
          92  +
    "TrimWhiteSpace",
   93     93   
    4,
   94     94   
);
   95     95   
static CSVCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96     96   
    CSVCONFIGURATION_SCHEMA_ID,
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98     98   
    &[
   99     99   
        &CSVCONFIGURATION_MEMBER_COLUMN_SEPARATOR,
  100    100   
        &CSVCONFIGURATION_MEMBER_ESCAPE_CHAR,
  101    101   
        &CSVCONFIGURATION_MEMBER_QUOTE_CHAR,
  102    102   
        &CSVCONFIGURATION_MEMBER_NULL_VALUE,
  103    103   
        &CSVCONFIGURATION_MEMBER_TRIM_WHITE_SPACE,
  104    104   
    ],
  105    105   
);
  106    106   
impl CsvConfiguration {
  107    107   
    /// The schema for this shape.
  108    108   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CSVCONFIGURATION_SCHEMA;
  109    109   
}
  110    110   
impl ::aws_smithy_schema::serde::SerializableStruct for CsvConfiguration {
  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.column_separator {
  117    117   
            ser.write_string(&CSVCONFIGURATION_MEMBER_COLUMN_SEPARATOR, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.escape_char {
  120    120   
            ser.write_string(&CSVCONFIGURATION_MEMBER_ESCAPE_CHAR, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.quote_char {
  123    123   
            ser.write_string(&CSVCONFIGURATION_MEMBER_QUOTE_CHAR, val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.null_value {
  126    126   
            ser.write_string(&CSVCONFIGURATION_MEMBER_NULL_VALUE, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.trim_white_space {
  129    129   
            ser.write_boolean(&CSVCONFIGURATION_MEMBER_TRIM_WHITE_SPACE, *val)?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl CsvConfiguration {
  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(&CSVCONFIGURATION_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&CSVCONFIGURATION_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.column_separator = Some(deser.read_string(member)?);
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.escape_char = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(2) => {
  157    157   
                    builder.quote_char = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(3) => {
  160    160   
                    builder.null_value = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                Some(4) => {
  163    163   
                    builder.trim_white_space = 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 CsvConfiguration {
         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 CsvConfiguration {
  173    184   
    /// Creates a new builder-style object to manufacture [`CsvConfiguration`](crate::types::CsvConfiguration).
  174    185   
    pub fn builder() -> crate::types::builders::CsvConfigurationBuilder {
  175    186   
        crate::types::builders::CsvConfigurationBuilder::default()
  176    187   
    }
  177    188   
}
  178    189   
  179    190   
/// A builder for [`CsvConfiguration`](crate::types::CsvConfiguration).
  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/timestreamwrite/src/types/_data_model.rs

@@ -28,28 +138,138 @@
   48     48   
}
   49     49   
static DATAMODEL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamwrite#DataModel", "com.amazonaws.timestreamwrite", "DataModel");
   51     51   
static DATAMODEL_MEMBER_TIME_COLUMN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.timestreamwrite#DataModel$TimeColumn",
   54     54   
        "com.amazonaws.timestreamwrite",
   55     55   
        "DataModel",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "time_column",
          58  +
    "TimeColumn",
   59     59   
    0,
   60     60   
);
   61     61   
static DATAMODEL_MEMBER_TIME_UNIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.timestreamwrite#DataModel$TimeUnit",
   64     64   
        "com.amazonaws.timestreamwrite",
   65     65   
        "DataModel",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "time_unit",
          68  +
    "TimeUnit",
   69     69   
    1,
   70     70   
);
   71     71   
static DATAMODEL_MEMBER_DIMENSION_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.timestreamwrite#DataModel$DimensionMappings",
   74     74   
        "com.amazonaws.timestreamwrite",
   75     75   
        "DataModel",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::List,
   78         -
    "dimension_mappings",
          78  +
    "DimensionMappings",
   79     79   
    2,
   80     80   
);
   81     81   
static DATAMODEL_MEMBER_MULTI_MEASURE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.timestreamwrite#DataModel$MultiMeasureMappings",
   84     84   
        "com.amazonaws.timestreamwrite",
   85     85   
        "DataModel",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "multi_measure_mappings",
          88  +
    "MultiMeasureMappings",
   89     89   
    3,
   90     90   
);
   91     91   
static DATAMODEL_MEMBER_MIXED_MEASURE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.timestreamwrite#DataModel$MixedMeasureMappings",
   94     94   
        "com.amazonaws.timestreamwrite",
   95     95   
        "DataModel",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::List,
   98         -
    "mixed_measure_mappings",
          98  +
    "MixedMeasureMappings",
   99     99   
    4,
  100    100   
);
  101    101   
static DATAMODEL_MEMBER_MEASURE_NAME_COLUMN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.timestreamwrite#DataModel$MeasureNameColumn",
  104    104   
        "com.amazonaws.timestreamwrite",
  105    105   
        "DataModel",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "measure_name_column",
         108  +
    "MeasureNameColumn",
  109    109   
    5,
  110    110   
);
  111    111   
static DATAMODEL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  112    112   
    DATAMODEL_SCHEMA_ID,
  113    113   
    ::aws_smithy_schema::ShapeType::Structure,
  114    114   
    &[
  115    115   
        &DATAMODEL_MEMBER_TIME_COLUMN,
  116    116   
        &DATAMODEL_MEMBER_TIME_UNIT,
  117    117   
        &DATAMODEL_MEMBER_DIMENSION_MAPPINGS,
  118    118   
        &DATAMODEL_MEMBER_MULTI_MEASURE_MAPPINGS,
@@ -144,144 +264,270 @@
  164    164   
            )?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.measure_name_column {
  167    167   
            ser.write_string(&DATAMODEL_MEMBER_MEASURE_NAME_COLUMN, val)?;
  168    168   
        }
  169    169   
        Ok(())
  170    170   
    }
  171    171   
}
  172    172   
impl DataModel {
  173    173   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  174         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  175         -
        deserializer: &mut D,
         174  +
    pub fn deserialize(
         175  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  176    176   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  177    177   
        #[allow(unused_variables, unused_mut)]
  178    178   
        let mut builder = Self::builder();
  179    179   
        #[allow(
  180    180   
            unused_variables,
  181    181   
            unreachable_code,
  182    182   
            clippy::single_match,
  183    183   
            clippy::match_single_binding,
  184    184   
            clippy::diverging_sub_expression
  185    185   
        )]
  186         -
        deserializer.read_struct(&DATAMODEL_SCHEMA, (), |_, member, deser| {
         186  +
        deserializer.read_struct(&DATAMODEL_SCHEMA, &mut |member, deser| {
  187    187   
            match member.member_index() {
  188    188   
                Some(0) => {
  189    189   
                    builder.time_column = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(1) => {
  192    192   
                    builder.time_unit = Some(crate::types::TimeUnit::from(deser.read_string(member)?.as_str()));
  193    193   
                }
  194    194   
                Some(2) => {
  195    195   
                    builder.dimension_mappings = Some({
  196         -
                        let container = if let Some(cap) = deser.container_size() {
  197         -
                            Vec::with_capacity(cap)
  198         -
                        } else {
  199         -
                            Vec::new()
  200         -
                        };
  201         -
                        deser.read_list(member, container, |mut list, deser| {
  202         -
                            list.push(crate::types::DimensionMapping::deserialize(deser)?);
  203         -
                            Ok(list)
  204         -
                        })?
         196  +
                        let mut container = Vec::new();
         197  +
                        deser.read_list(member, &mut |deser| {
         198  +
                            container.push(crate::types::DimensionMapping::deserialize(deser)?);
         199  +
                            Ok(())
         200  +
                        })?;
         201  +
                        container
  205    202   
                    });
  206    203   
                }
  207    204   
                Some(3) => {
  208    205   
                    builder.multi_measure_mappings = Some(crate::types::MultiMeasureMappings::deserialize(deser)?);
  209    206   
                }
  210    207   
                Some(4) => {
  211    208   
                    builder.mixed_measure_mappings = Some({
  212         -
                        let container = if let Some(cap) = deser.container_size() {
  213         -
                            Vec::with_capacity(cap)
  214         -
                        } else {
  215         -
                            Vec::new()
  216         -
                        };
  217         -
                        deser.read_list(member, container, |mut list, deser| {
  218         -
                            list.push(crate::types::MixedMeasureMapping::deserialize(deser)?);
  219         -
                            Ok(list)
  220         -
                        })?
         209  +
                        let mut container = Vec::new();
         210  +
                        deser.read_list(member, &mut |deser| {
         211  +
                            container.push(crate::types::MixedMeasureMapping::deserialize(deser)?);
         212  +
                            Ok(())
         213  +
                        })?;
         214  +
                        container
  221    215   
                    });
  222    216   
                }
  223    217   
                Some(5) => {
  224    218   
                    builder.measure_name_column = Some(deser.read_string(member)?);
  225    219   
                }
  226    220   
                _ => {}
  227    221   
            }
  228    222   
            Ok(())
  229    223   
        })?;
         224  +
        builder.dimension_mappings = builder.dimension_mappings.or(Some(Vec::new()));
  230    225   
        builder
  231    226   
            .build()
  232    227   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  233    228   
    }
  234    229   
}
         230  +
impl DataModel {
         231  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         232  +
    pub fn deserialize_with_response(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         234  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         235  +
        _status: u16,
         236  +
        _body: &[u8],
         237  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         238  +
        Self::deserialize(deserializer)
         239  +
    }
         240  +
}
  235    241   
impl DataModel {
  236    242   
    /// Creates a new builder-style object to manufacture [`DataModel`](crate::types::DataModel).
  237    243   
    pub fn builder() -> crate::types::builders::DataModelBuilder {
  238    244   
        crate::types::builders::DataModelBuilder::default()
  239    245   
    }
  240    246   
}
  241    247   
  242    248   
/// A builder for [`DataModel`](crate::types::DataModel).
  243    249   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  244    250   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_data_model_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_data_model_s3_configuration.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_data_source_s3_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_database.rs

@@ -21,21 +218,229 @@
   41     41   
    /// <p>The last time that this database was updated.</p>
   42     42   
    pub fn last_updated_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   43     43   
        self.last_updated_time.as_ref()
   44     44   
    }
   45     45   
}
   46     46   
static DATABASE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamwrite#Database", "com.amazonaws.timestreamwrite", "Database");
   48     48   
static DATABASE_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamwrite#Database$Arn", "com.amazonaws.timestreamwrite", "Database"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "arn",
          51  +
    "Arn",
   52     52   
    0,
   53     53   
);
   54     54   
static DATABASE_MEMBER_DATABASE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.timestreamwrite#Database$DatabaseName",
   57     57   
        "com.amazonaws.timestreamwrite",
   58     58   
        "Database",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "database_name",
          61  +
    "DatabaseName",
   62     62   
    1,
   63     63   
);
   64     64   
static DATABASE_MEMBER_TABLE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.timestreamwrite#Database$TableCount",
   67     67   
        "com.amazonaws.timestreamwrite",
   68     68   
        "Database",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::Long,
   71         -
    "table_count",
          71  +
    "TableCount",
   72     72   
    2,
   73     73   
);
   74     74   
static DATABASE_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.timestreamwrite#Database$KmsKeyId",
   77     77   
        "com.amazonaws.timestreamwrite",
   78     78   
        "Database",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "kms_key_id",
          81  +
    "KmsKeyId",
   82     82   
    3,
   83     83   
);
   84     84   
static DATABASE_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.timestreamwrite#Database$CreationTime",
   87     87   
        "com.amazonaws.timestreamwrite",
   88     88   
        "Database",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::Timestamp,
   91         -
    "creation_time",
          91  +
    "CreationTime",
   92     92   
    4,
   93     93   
);
   94     94   
static DATABASE_MEMBER_LAST_UPDATED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "com.amazonaws.timestreamwrite#Database$LastUpdatedTime",
   97     97   
        "com.amazonaws.timestreamwrite",
   98     98   
        "Database",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::Timestamp,
  101         -
    "last_updated_time",
         101  +
    "LastUpdatedTime",
  102    102   
    5,
  103    103   
);
  104    104   
static DATABASE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  105    105   
    DATABASE_SCHEMA_ID,
  106    106   
    ::aws_smithy_schema::ShapeType::Structure,
  107    107   
    &[
  108    108   
        &DATABASE_MEMBER_ARN,
  109    109   
        &DATABASE_MEMBER_DATABASE_NAME,
  110    110   
        &DATABASE_MEMBER_TABLE_COUNT,
  111    111   
        &DATABASE_MEMBER_KMS_KEY_ID,
  112    112   
        &DATABASE_MEMBER_CREATION_TIME,
  113    113   
        &DATABASE_MEMBER_LAST_UPDATED_TIME,
  114    114   
    ],
  115    115   
);
  116    116   
impl Database {
  117    117   
    /// The schema for this shape.
  118    118   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DATABASE_SCHEMA;
  119    119   
}
  120    120   
impl ::aws_smithy_schema::serde::SerializableStruct for Database {
  121    121   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  122    122   
    fn serialize_members(
  123    123   
        &self,
  124    124   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  125    125   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  126    126   
        if let Some(ref val) = self.arn {
  127    127   
            ser.write_string(&DATABASE_MEMBER_ARN, val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.database_name {
  130    130   
            ser.write_string(&DATABASE_MEMBER_DATABASE_NAME, val)?;
  131    131   
        }
  132    132   
        {
  133    133   
            let val = &self.table_count;
  134    134   
            ser.write_long(&DATABASE_MEMBER_TABLE_COUNT, *val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.kms_key_id {
  137    137   
            ser.write_string(&DATABASE_MEMBER_KMS_KEY_ID, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.creation_time {
  140    140   
            ser.write_timestamp(&DATABASE_MEMBER_CREATION_TIME, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.last_updated_time {
  143    143   
            ser.write_timestamp(&DATABASE_MEMBER_LAST_UPDATED_TIME, val)?;
  144    144   
        }
  145    145   
        Ok(())
  146    146   
    }
  147    147   
}
  148    148   
impl Database {
  149    149   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  150         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  151         -
        deserializer: &mut D,
         150  +
    pub fn deserialize(
         151  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  152    152   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  153    153   
        #[allow(unused_variables, unused_mut)]
  154    154   
        let mut builder = Self::builder();
  155    155   
        #[allow(
  156    156   
            unused_variables,
  157    157   
            unreachable_code,
  158    158   
            clippy::single_match,
  159    159   
            clippy::match_single_binding,
  160    160   
            clippy::diverging_sub_expression
  161    161   
        )]
  162         -
        deserializer.read_struct(&DATABASE_SCHEMA, (), |_, member, deser| {
         162  +
        deserializer.read_struct(&DATABASE_SCHEMA, &mut |member, deser| {
  163    163   
            match member.member_index() {
  164    164   
                Some(0) => {
  165    165   
                    builder.arn = Some(deser.read_string(member)?);
  166    166   
                }
  167    167   
                Some(1) => {
  168    168   
                    builder.database_name = Some(deser.read_string(member)?);
  169    169   
                }
  170    170   
                Some(2) => {
  171    171   
                    builder.table_count = Some(deser.read_long(member)?);
  172    172   
                }
  173    173   
                Some(3) => {
  174    174   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  175    175   
                }
  176    176   
                Some(4) => {
  177    177   
                    builder.creation_time = Some(deser.read_timestamp(member)?);
  178    178   
                }
  179    179   
                Some(5) => {
  180    180   
                    builder.last_updated_time = Some(deser.read_timestamp(member)?);
  181    181   
                }
  182    182   
                _ => {}
  183    183   
            }
  184    184   
            Ok(())
  185    185   
        })?;
  186    186   
        Ok(builder.build())
  187    187   
    }
  188    188   
}
         189  +
impl Database {
         190  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         191  +
    pub fn deserialize_with_response(
         192  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         193  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         194  +
        _status: u16,
         195  +
        _body: &[u8],
         196  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         197  +
        Self::deserialize(deserializer)
         198  +
    }
         199  +
}
  189    200   
impl Database {
  190    201   
    /// Creates a new builder-style object to manufacture [`Database`](crate::types::Database).
  191    202   
    pub fn builder() -> crate::types::builders::DatabaseBuilder {
  192    203   
        crate::types::builders::DatabaseBuilder::default()
  193    204   
    }
  194    205   
}
  195    206   
  196    207   
/// A builder for [`Database`](crate::types::Database).
  197    208   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  198    209   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_dimension.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_dimension_mapping.rs

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

@@ -2,2 +131,144 @@
   22     22   
}
   23     23   
static ENDPOINT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   24     24   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.timestreamwrite#Endpoint", "com.amazonaws.timestreamwrite", "Endpoint");
   25     25   
static ENDPOINT_MEMBER_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   26     26   
    ::aws_smithy_schema::ShapeId::from_static(
   27     27   
        "com.amazonaws.timestreamwrite#Endpoint$Address",
   28     28   
        "com.amazonaws.timestreamwrite",
   29     29   
        "Endpoint",
   30     30   
    ),
   31     31   
    ::aws_smithy_schema::ShapeType::String,
   32         -
    "address",
          32  +
    "Address",
   33     33   
    0,
   34     34   
);
   35     35   
static ENDPOINT_MEMBER_CACHE_PERIOD_IN_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.timestreamwrite#Endpoint$CachePeriodInMinutes",
   38     38   
        "com.amazonaws.timestreamwrite",
   39     39   
        "Endpoint",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::Long,
   42         -
    "cache_period_in_minutes",
          42  +
    "CachePeriodInMinutes",
   43     43   
    1,
   44     44   
);
   45     45   
static ENDPOINT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   46     46   
    ENDPOINT_SCHEMA_ID,
   47     47   
    ::aws_smithy_schema::ShapeType::Structure,
   48     48   
    &[&ENDPOINT_MEMBER_ADDRESS, &ENDPOINT_MEMBER_CACHE_PERIOD_IN_MINUTES],
   49     49   
);
   50     50   
impl Endpoint {
   51     51   
    /// The schema for this shape.
   52     52   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENDPOINT_SCHEMA;
   53     53   
}
   54     54   
impl ::aws_smithy_schema::serde::SerializableStruct for Endpoint {
   55     55   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   56     56   
    fn serialize_members(
   57     57   
        &self,
   58     58   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   59     59   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   60     60   
        {
   61     61   
            let val = &self.address;
   62     62   
            ser.write_string(&ENDPOINT_MEMBER_ADDRESS, val)?;
   63     63   
        }
   64     64   
        {
   65     65   
            let val = &self.cache_period_in_minutes;
   66     66   
            ser.write_long(&ENDPOINT_MEMBER_CACHE_PERIOD_IN_MINUTES, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl Endpoint {
   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(&ENDPOINT_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&ENDPOINT_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.address = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.cache_period_in_minutes = Some(deser.read_long(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
          97  +
        builder.address = builder.address.or(Some(String::new()));
          98  +
        builder.cache_period_in_minutes = builder.cache_period_in_minutes.or(Some(0i64));
   97     99   
        builder
   98    100   
            .build()
   99    101   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  100    102   
    }
  101    103   
}
         104  +
impl Endpoint {
         105  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         106  +
    pub fn deserialize_with_response(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         108  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         109  +
        _status: u16,
         110  +
        _body: &[u8],
         111  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         112  +
        Self::deserialize(deserializer)
         113  +
    }
         114  +
}
  102    115   
impl Endpoint {
  103    116   
    /// Creates a new builder-style object to manufacture [`Endpoint`](crate::types::Endpoint).
  104    117   
    pub fn builder() -> crate::types::builders::EndpointBuilder {
  105    118   
        crate::types::builders::EndpointBuilder::default()
  106    119   
    }
  107    120   
}
  108    121   
  109    122   
/// A builder for [`Endpoint`](crate::types::Endpoint).
  110    123   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    124   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/_magnetic_store_rejected_data_location.rs

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.timestreamwrite",
   19     19   
    "MagneticStoreRejectedDataLocation",
   20     20   
);
   21     21   
static MAGNETICSTOREREJECTEDDATALOCATION_MEMBER_S3_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.timestreamwrite#MagneticStoreRejectedDataLocation$S3Configuration",
   24     24   
        "com.amazonaws.timestreamwrite",
   25     25   
        "MagneticStoreRejectedDataLocation",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "s3_configuration",
          28  +
    "S3Configuration",
   29     29   
    0,
   30     30   
);
   31     31   
static MAGNETICSTOREREJECTEDDATALOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    MAGNETICSTOREREJECTEDDATALOCATION_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&MAGNETICSTOREREJECTEDDATALOCATION_MEMBER_S3_CONFIGURATION],
   35     35   
);
   36     36   
impl MagneticStoreRejectedDataLocation {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MAGNETICSTOREREJECTEDDATALOCATION_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for MagneticStoreRejectedDataLocation {
   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.s3_configuration {
   47     47   
            ser.write_struct(&MAGNETICSTOREREJECTEDDATALOCATION_MEMBER_S3_CONFIGURATION, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl MagneticStoreRejectedDataLocation {
   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(&MAGNETICSTOREREJECTEDDATALOCATION_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&MAGNETICSTOREREJECTEDDATALOCATION_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.s3_configuration = Some(crate::types::S3Configuration::deserialize(deser)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl MagneticStoreRejectedDataLocation {
          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 MagneticStoreRejectedDataLocation {
   79     90   
    /// Creates a new builder-style object to manufacture [`MagneticStoreRejectedDataLocation`](crate::types::MagneticStoreRejectedDataLocation).
   80     91   
    pub fn builder() -> crate::types::builders::MagneticStoreRejectedDataLocationBuilder {
   81     92   
        crate::types::builders::MagneticStoreRejectedDataLocationBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`MagneticStoreRejectedDataLocation`](crate::types::MagneticStoreRejectedDataLocation).
   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/timestreamwrite/src/types/_magnetic_store_write_properties.rs

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