AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_select_object_content_event_stream.rs

@@ -68,68 +0,216 @@
   88     88   
    }
   89     89   
    /// Returns true if this is a [`Stats`](crate::types::SelectObjectContentEventStream::Stats).
   90     90   
    pub fn is_stats(&self) -> bool {
   91     91   
        self.as_stats().is_ok()
   92     92   
    }
   93     93   
    /// Returns true if the enum instance is the `Unknown` variant.
   94     94   
    pub fn is_unknown(&self) -> bool {
   95     95   
        matches!(self, Self::Unknown)
   96     96   
    }
   97     97   
}
          98  +
static SELECTOBJECTCONTENTEVENTSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          99  +
    "com.amazonaws.s3#SelectObjectContentEventStream",
         100  +
    "com.amazonaws.s3",
         101  +
    "SelectObjectContentEventStream",
         102  +
);
         103  +
static SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_RECORDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         104  +
    ::aws_smithy_schema::ShapeId::from_static(
         105  +
        "com.amazonaws.s3#SelectObjectContentEventStream$Records",
         106  +
        "com.amazonaws.s3",
         107  +
        "SelectObjectContentEventStream",
         108  +
    ),
         109  +
    ::aws_smithy_schema::ShapeType::Structure,
         110  +
    "Records",
         111  +
    0,
         112  +
);
         113  +
static SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_STATS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         114  +
    ::aws_smithy_schema::ShapeId::from_static(
         115  +
        "com.amazonaws.s3#SelectObjectContentEventStream$Stats",
         116  +
        "com.amazonaws.s3",
         117  +
        "SelectObjectContentEventStream",
         118  +
    ),
         119  +
    ::aws_smithy_schema::ShapeType::Structure,
         120  +
    "Stats",
         121  +
    1,
         122  +
);
         123  +
static SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         124  +
    ::aws_smithy_schema::ShapeId::from_static(
         125  +
        "com.amazonaws.s3#SelectObjectContentEventStream$Progress",
         126  +
        "com.amazonaws.s3",
         127  +
        "SelectObjectContentEventStream",
         128  +
    ),
         129  +
    ::aws_smithy_schema::ShapeType::Structure,
         130  +
    "Progress",
         131  +
    2,
         132  +
);
         133  +
static SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_CONT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         134  +
    ::aws_smithy_schema::ShapeId::from_static(
         135  +
        "com.amazonaws.s3#SelectObjectContentEventStream$Cont",
         136  +
        "com.amazonaws.s3",
         137  +
        "SelectObjectContentEventStream",
         138  +
    ),
         139  +
    ::aws_smithy_schema::ShapeType::Structure,
         140  +
    "Cont",
         141  +
    3,
         142  +
);
         143  +
static SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         144  +
    ::aws_smithy_schema::ShapeId::from_static(
         145  +
        "com.amazonaws.s3#SelectObjectContentEventStream$End",
         146  +
        "com.amazonaws.s3",
         147  +
        "SelectObjectContentEventStream",
         148  +
    ),
         149  +
    ::aws_smithy_schema::ShapeType::Structure,
         150  +
    "End",
         151  +
    4,
         152  +
);
         153  +
static SELECTOBJECTCONTENTEVENTSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         154  +
    SELECTOBJECTCONTENTEVENTSTREAM_SCHEMA_ID,
         155  +
    ::aws_smithy_schema::ShapeType::Union,
         156  +
    &[
         157  +
        &SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_RECORDS,
         158  +
        &SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_STATS,
         159  +
        &SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_PROGRESS,
         160  +
        &SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_CONT,
         161  +
        &SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_END,
         162  +
    ],
         163  +
)
         164  +
.with_streaming();
         165  +
impl SelectObjectContentEventStream {
         166  +
    /// The schema for this shape.
         167  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SELECTOBJECTCONTENTEVENTSTREAM_SCHEMA;
         168  +
}
         169  +
impl ::aws_smithy_schema::serde::SerializableStruct for SelectObjectContentEventStream {
         170  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         171  +
    fn serialize_members(
         172  +
        &self,
         173  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         174  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         175  +
        match self {
         176  +
            Self::Records(val) => {
         177  +
                ser.write_struct(&SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_RECORDS, val)?;
         178  +
            }
         179  +
            Self::Stats(val) => {
         180  +
                ser.write_struct(&SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_STATS, val)?;
         181  +
            }
         182  +
            Self::Progress(val) => {
         183  +
                ser.write_struct(&SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_PROGRESS, val)?;
         184  +
            }
         185  +
            Self::Cont(val) => {
         186  +
                ser.write_struct(&SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_CONT, val)?;
         187  +
            }
         188  +
            Self::End(val) => {
         189  +
                ser.write_struct(&SELECTOBJECTCONTENTEVENTSTREAM_MEMBER_END, val)?;
         190  +
            }
         191  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         192  +
        }
         193  +
        Ok(())
         194  +
    }
         195  +
}
         196  +
impl SelectObjectContentEventStream {
         197  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         198  +
    pub fn deserialize(
         199  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         200  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         201  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         202  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         203  +
        deserializer.read_struct(&SELECTOBJECTCONTENTEVENTSTREAM_SCHEMA, &mut |member, deser| {
         204  +
            result = ::std::option::Option::Some(match member.member_index() {
         205  +
                Some(0) => Self::Records(crate::types::RecordsEvent::deserialize(deser)?),
         206  +
                Some(1) => Self::Stats(crate::types::StatsEvent::deserialize(deser)?),
         207  +
                Some(2) => Self::Progress(crate::types::ProgressEvent::deserialize(deser)?),
         208  +
                Some(3) => Self::Cont(crate::types::ContinuationEvent::deserialize(deser)?),
         209  +
                Some(4) => Self::End(crate::types::EndEvent::deserialize(deser)?),
         210  +
                _ => Self::Unknown,
         211  +
            });
         212  +
            Ok(())
         213  +
        })?;
         214  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         215  +
    }
         216  +
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_select_parameters.rs

@@ -24,24 +182,194 @@
   44     44   
}
   45     45   
static SELECTPARAMETERS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   46     46   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SelectParameters", "com.amazonaws.s3", "SelectParameters");
   47     47   
static SELECTPARAMETERS_MEMBER_INPUT_SERIALIZATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.s3#SelectParameters$InputSerialization",
   50     50   
        "com.amazonaws.s3",
   51     51   
        "SelectParameters",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54         -
    "input_serialization",
          54  +
    "InputSerialization",
   55     55   
    0,
   56     56   
);
   57     57   
static SELECTPARAMETERS_MEMBER_EXPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SelectParameters$ExpressionType", "com.amazonaws.s3", "SelectParameters"),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "expression_type",
          60  +
    "ExpressionType",
   61     61   
    1,
   62     62   
);
   63     63   
static SELECTPARAMETERS_MEMBER_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SelectParameters$Expression", "com.amazonaws.s3", "SelectParameters"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "expression",
          66  +
    "Expression",
   67     67   
    2,
   68     68   
);
   69     69   
static SELECTPARAMETERS_MEMBER_OUTPUT_SERIALIZATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.s3#SelectParameters$OutputSerialization",
   72     72   
        "com.amazonaws.s3",
   73     73   
        "SelectParameters",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Structure,
   76         -
    "output_serialization",
          76  +
    "OutputSerialization",
   77     77   
    3,
   78     78   
);
   79     79   
static SELECTPARAMETERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    SELECTPARAMETERS_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &SELECTPARAMETERS_MEMBER_INPUT_SERIALIZATION,
   84     84   
        &SELECTPARAMETERS_MEMBER_EXPRESSION_TYPE,
   85     85   
        &SELECTPARAMETERS_MEMBER_EXPRESSION,
   86     86   
        &SELECTPARAMETERS_MEMBER_OUTPUT_SERIALIZATION,
   87     87   
    ],
   88     88   
);
   89     89   
impl SelectParameters {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SELECTPARAMETERS_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for SelectParameters {
   94     94   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   95     95   
    fn serialize_members(
   96     96   
        &self,
   97     97   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   98     98   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        if let Some(ref val) = self.input_serialization {
  100    100   
            ser.write_struct(&SELECTPARAMETERS_MEMBER_INPUT_SERIALIZATION, val)?;
  101    101   
        }
  102    102   
        {
  103    103   
            let val = &self.expression_type;
  104    104   
            ser.write_string(&SELECTPARAMETERS_MEMBER_EXPRESSION_TYPE, val.as_str())?;
  105    105   
        }
  106    106   
        {
  107    107   
            let val = &self.expression;
  108    108   
            ser.write_string(&SELECTPARAMETERS_MEMBER_EXPRESSION, val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.output_serialization {
  111    111   
            ser.write_struct(&SELECTPARAMETERS_MEMBER_OUTPUT_SERIALIZATION, val)?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl SelectParameters {
  117    117   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        #[allow(unused_variables, unused_mut)]
  122    122   
        let mut builder = Self::builder();
  123    123   
        #[allow(
  124    124   
            unused_variables,
  125    125   
            unreachable_code,
  126    126   
            clippy::single_match,
  127    127   
            clippy::match_single_binding,
  128    128   
            clippy::diverging_sub_expression
  129    129   
        )]
  130         -
        deserializer.read_struct(&SELECTPARAMETERS_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&SELECTPARAMETERS_SCHEMA, &mut |member, deser| {
  131    131   
            match member.member_index() {
  132    132   
                Some(0) => {
  133    133   
                    builder.input_serialization = Some(crate::types::InputSerialization::deserialize(deser)?);
  134    134   
                }
  135    135   
                Some(1) => {
  136    136   
                    builder.expression_type = Some(crate::types::ExpressionType::from(deser.read_string(member)?.as_str()));
  137    137   
                }
  138    138   
                Some(2) => {
  139    139   
                    builder.expression = Some(deser.read_string(member)?);
  140    140   
                }
  141    141   
                Some(3) => {
  142    142   
                    builder.output_serialization = Some(crate::types::OutputSerialization::deserialize(deser)?);
  143    143   
                }
  144    144   
                _ => {}
  145    145   
            }
  146    146   
            Ok(())
  147    147   
        })?;
         148  +
        builder.expression = builder.expression.or(Some(String::new()));
  148    149   
        builder
  149    150   
            .build()
  150    151   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  151    152   
    }
  152    153   
}
         154  +
impl SelectParameters {
         155  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         156  +
    pub fn deserialize_with_response(
         157  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         158  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         159  +
        _status: u16,
         160  +
        _body: &[u8],
         161  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         162  +
        Self::deserialize(deserializer)
         163  +
    }
         164  +
}
  153    165   
impl SelectParameters {
  154    166   
    /// Creates a new builder-style object to manufacture [`SelectParameters`](crate::types::SelectParameters).
  155    167   
    pub fn builder() -> crate::types::builders::SelectParametersBuilder {
  156    168   
        crate::types::builders::SelectParametersBuilder::default()
  157    169   
    }
  158    170   
}
  159    171   
  160    172   
/// A builder for [`SelectParameters`](crate::types::SelectParameters).
  161    173   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  162    174   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_server_side_encryption_by_default.rs

@@ -77,77 +208,219 @@
   97     97   
    "com.amazonaws.s3",
   98     98   
    "ServerSideEncryptionByDefault",
   99     99   
);
  100    100   
static SERVERSIDEENCRYPTIONBYDEFAULT_MEMBER_SSE_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.s3#ServerSideEncryptionByDefault$SSEAlgorithm",
  103    103   
        "com.amazonaws.s3",
  104    104   
        "ServerSideEncryptionByDefault",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "sse_algorithm",
         107  +
    "SSEAlgorithm",
  108    108   
    0,
  109    109   
);
  110    110   
static SERVERSIDEENCRYPTIONBYDEFAULT_MEMBER_KMS_MASTER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.s3#ServerSideEncryptionByDefault$KMSMasterKeyID",
  113    113   
        "com.amazonaws.s3",
  114    114   
        "ServerSideEncryptionByDefault",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "kms_master_key_id",
         117  +
    "KMSMasterKeyID",
  118    118   
    1,
  119    119   
);
  120    120   
static SERVERSIDEENCRYPTIONBYDEFAULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  121    121   
    SERVERSIDEENCRYPTIONBYDEFAULT_SCHEMA_ID,
  122    122   
    ::aws_smithy_schema::ShapeType::Structure,
  123    123   
    &[
  124    124   
        &SERVERSIDEENCRYPTIONBYDEFAULT_MEMBER_SSE_ALGORITHM,
  125    125   
        &SERVERSIDEENCRYPTIONBYDEFAULT_MEMBER_KMS_MASTER_KEY_ID,
  126    126   
    ],
  127    127   
);
  128    128   
impl ServerSideEncryptionByDefault {
  129    129   
    /// The schema for this shape.
  130    130   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVERSIDEENCRYPTIONBYDEFAULT_SCHEMA;
  131    131   
}
  132    132   
impl ::aws_smithy_schema::serde::SerializableStruct for ServerSideEncryptionByDefault {
  133    133   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  134    134   
    fn serialize_members(
  135    135   
        &self,
  136    136   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  137    137   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  138    138   
        {
  139    139   
            let val = &self.sse_algorithm;
  140    140   
            ser.write_string(&SERVERSIDEENCRYPTIONBYDEFAULT_MEMBER_SSE_ALGORITHM, val.as_str())?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.kms_master_key_id {
  143    143   
            ser.write_string(&SERVERSIDEENCRYPTIONBYDEFAULT_MEMBER_KMS_MASTER_KEY_ID, val)?;
  144    144   
        }
  145    145   
        Ok(())
  146    146   
    }
  147    147   
}
  148    148   
impl ServerSideEncryptionByDefault {
  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(&SERVERSIDEENCRYPTIONBYDEFAULT_SCHEMA, (), |_, member, deser| {
         162  +
        deserializer.read_struct(&SERVERSIDEENCRYPTIONBYDEFAULT_SCHEMA, &mut |member, deser| {
  163    163   
            match member.member_index() {
  164    164   
                Some(0) => {
  165    165   
                    builder.sse_algorithm = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
  166    166   
                }
  167    167   
                Some(1) => {
  168    168   
                    builder.kms_master_key_id = Some(deser.read_string(member)?);
  169    169   
                }
  170    170   
                _ => {}
  171    171   
            }
  172    172   
            Ok(())
  173    173   
        })?;
  174    174   
        builder
  175    175   
            .build()
  176    176   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  177    177   
    }
  178    178   
}
         179  +
impl ServerSideEncryptionByDefault {
         180  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         181  +
    pub fn deserialize_with_response(
         182  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         183  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         184  +
        _status: u16,
         185  +
        _body: &[u8],
         186  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         187  +
        Self::deserialize(deserializer)
         188  +
    }
         189  +
}
  179    190   
impl ServerSideEncryptionByDefault {
  180    191   
    /// Creates a new builder-style object to manufacture [`ServerSideEncryptionByDefault`](crate::types::ServerSideEncryptionByDefault).
  181    192   
    pub fn builder() -> crate::types::builders::ServerSideEncryptionByDefaultBuilder {
  182    193   
        crate::types::builders::ServerSideEncryptionByDefaultBuilder::default()
  183    194   
    }
  184    195   
}
  185    196   
  186    197   
/// A builder for [`ServerSideEncryptionByDefault`](crate::types::ServerSideEncryptionByDefault).
  187    198   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  188    199   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_server_side_encryption_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_server_side_encryption_rule.rs

@@ -35,35 +180,191 @@
   55     55   
    "com.amazonaws.s3",
   56     56   
    "ServerSideEncryptionRule",
   57     57   
);
   58     58   
static SERVERSIDEENCRYPTIONRULE_MEMBER_APPLY_SERVER_SIDE_ENCRYPTION_BY_DEFAULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.s3#ServerSideEncryptionRule$ApplyServerSideEncryptionByDefault",
   61     61   
        "com.amazonaws.s3",
   62     62   
        "ServerSideEncryptionRule",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65         -
    "apply_server_side_encryption_by_default",
          65  +
    "ApplyServerSideEncryptionByDefault",
   66     66   
    0,
   67     67   
);
   68     68   
static SERVERSIDEENCRYPTIONRULE_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.s3#ServerSideEncryptionRule$BucketKeyEnabled",
   71     71   
        "com.amazonaws.s3",
   72     72   
        "ServerSideEncryptionRule",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::Boolean,
   75         -
    "bucket_key_enabled",
          75  +
    "BucketKeyEnabled",
   76     76   
    1,
   77     77   
);
   78     78   
static SERVERSIDEENCRYPTIONRULE_MEMBER_BLOCKED_ENCRYPTION_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.s3#ServerSideEncryptionRule$BlockedEncryptionTypes",
   81     81   
        "com.amazonaws.s3",
   82     82   
        "ServerSideEncryptionRule",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::Structure,
   85         -
    "blocked_encryption_types",
          85  +
    "BlockedEncryptionTypes",
   86     86   
    2,
   87     87   
);
   88     88   
static SERVERSIDEENCRYPTIONRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   89     89   
    SERVERSIDEENCRYPTIONRULE_SCHEMA_ID,
   90     90   
    ::aws_smithy_schema::ShapeType::Structure,
   91     91   
    &[
   92     92   
        &SERVERSIDEENCRYPTIONRULE_MEMBER_APPLY_SERVER_SIDE_ENCRYPTION_BY_DEFAULT,
   93     93   
        &SERVERSIDEENCRYPTIONRULE_MEMBER_BUCKET_KEY_ENABLED,
   94     94   
        &SERVERSIDEENCRYPTIONRULE_MEMBER_BLOCKED_ENCRYPTION_TYPES,
   95     95   
    ],
   96     96   
);
   97     97   
impl ServerSideEncryptionRule {
   98     98   
    /// The schema for this shape.
   99     99   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVERSIDEENCRYPTIONRULE_SCHEMA;
  100    100   
}
  101    101   
impl ::aws_smithy_schema::serde::SerializableStruct for ServerSideEncryptionRule {
  102    102   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  103    103   
    fn serialize_members(
  104    104   
        &self,
  105    105   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  106    106   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  107    107   
        if let Some(ref val) = self.apply_server_side_encryption_by_default {
  108    108   
            ser.write_struct(&SERVERSIDEENCRYPTIONRULE_MEMBER_APPLY_SERVER_SIDE_ENCRYPTION_BY_DEFAULT, val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.bucket_key_enabled {
  111    111   
            ser.write_boolean(&SERVERSIDEENCRYPTIONRULE_MEMBER_BUCKET_KEY_ENABLED, *val)?;
  112    112   
        }
  113    113   
        if let Some(ref val) = self.blocked_encryption_types {
  114    114   
            ser.write_struct(&SERVERSIDEENCRYPTIONRULE_MEMBER_BLOCKED_ENCRYPTION_TYPES, val)?;
  115    115   
        }
  116    116   
        Ok(())
  117    117   
    }
  118    118   
}
  119    119   
impl ServerSideEncryptionRule {
  120    120   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  121         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  122         -
        deserializer: &mut D,
         121  +
    pub fn deserialize(
         122  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  123    123   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  124    124   
        #[allow(unused_variables, unused_mut)]
  125    125   
        let mut builder = Self::builder();
  126    126   
        #[allow(
  127    127   
            unused_variables,
  128    128   
            unreachable_code,
  129    129   
            clippy::single_match,
  130    130   
            clippy::match_single_binding,
  131    131   
            clippy::diverging_sub_expression
  132    132   
        )]
  133         -
        deserializer.read_struct(&SERVERSIDEENCRYPTIONRULE_SCHEMA, (), |_, member, deser| {
         133  +
        deserializer.read_struct(&SERVERSIDEENCRYPTIONRULE_SCHEMA, &mut |member, deser| {
  134    134   
            match member.member_index() {
  135    135   
                Some(0) => {
  136    136   
                    builder.apply_server_side_encryption_by_default = Some(crate::types::ServerSideEncryptionByDefault::deserialize(deser)?);
  137    137   
                }
  138    138   
                Some(1) => {
  139    139   
                    builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
  140    140   
                }
  141    141   
                Some(2) => {
  142    142   
                    builder.blocked_encryption_types = Some(crate::types::BlockedEncryptionTypes::deserialize(deser)?);
  143    143   
                }
  144    144   
                _ => {}
  145    145   
            }
  146    146   
            Ok(())
  147    147   
        })?;
  148    148   
        Ok(builder.build())
  149    149   
    }
  150    150   
}
         151  +
impl ServerSideEncryptionRule {
         152  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         153  +
    pub fn deserialize_with_response(
         154  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         155  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         156  +
        _status: u16,
         157  +
        _body: &[u8],
         158  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         159  +
        Self::deserialize(deserializer)
         160  +
    }
         161  +
}
  151    162   
impl ServerSideEncryptionRule {
  152    163   
    /// Creates a new builder-style object to manufacture [`ServerSideEncryptionRule`](crate::types::ServerSideEncryptionRule).
  153    164   
    pub fn builder() -> crate::types::builders::ServerSideEncryptionRuleBuilder {
  154    165   
        crate::types::builders::ServerSideEncryptionRuleBuilder::default()
  155    166   
    }
  156    167   
}
  157    168   
  158    169   
/// A builder for [`ServerSideEncryptionRule`](crate::types::ServerSideEncryptionRule).
  159    170   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  160    171   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_session_credentials.rs

@@ -28,28 +196,211 @@
   48     48   
}
   49     49   
static SESSIONCREDENTIALS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SessionCredentials", "com.amazonaws.s3", "SessionCredentials");
   51     51   
static SESSIONCREDENTIALS_MEMBER_ACCESS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.s3#SessionCredentials$AccessKeyId",
   54     54   
        "com.amazonaws.s3",
   55     55   
        "SessionCredentials",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "access_key_id",
          58  +
    "AccessKeyId",
   59     59   
    0,
   60     60   
)
   61     61   
.with_xml_name("AccessKeyId");
   62     62   
static SESSIONCREDENTIALS_MEMBER_SECRET_ACCESS_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.s3#SessionCredentials$SecretAccessKey",
   65     65   
        "com.amazonaws.s3",
   66     66   
        "SessionCredentials",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "secret_access_key",
          69  +
    "SecretAccessKey",
   70     70   
    1,
   71     71   
)
   72     72   
.with_xml_name("SecretAccessKey");
   73     73   
static SESSIONCREDENTIALS_MEMBER_SESSION_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.s3#SessionCredentials$SessionToken",
   76     76   
        "com.amazonaws.s3",
   77     77   
        "SessionCredentials",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "session_token",
          80  +
    "SessionToken",
   81     81   
    2,
   82     82   
)
   83     83   
.with_xml_name("SessionToken");
   84     84   
static SESSIONCREDENTIALS_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SessionCredentials$Expiration", "com.amazonaws.s3", "SessionCredentials"),
   86     86   
    ::aws_smithy_schema::ShapeType::Timestamp,
   87         -
    "expiration",
          87  +
    "Expiration",
   88     88   
    3,
   89     89   
)
   90     90   
.with_xml_name("Expiration");
   91     91   
static SESSIONCREDENTIALS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   92     92   
    SESSIONCREDENTIALS_SCHEMA_ID,
   93     93   
    ::aws_smithy_schema::ShapeType::Structure,
   94     94   
    &[
   95     95   
        &SESSIONCREDENTIALS_MEMBER_ACCESS_KEY_ID,
   96     96   
        &SESSIONCREDENTIALS_MEMBER_SECRET_ACCESS_KEY,
   97     97   
        &SESSIONCREDENTIALS_MEMBER_SESSION_TOKEN,
   98     98   
        &SESSIONCREDENTIALS_MEMBER_EXPIRATION,
   99     99   
    ],
  100    100   
);
  101    101   
impl SessionCredentials {
  102    102   
    /// The schema for this shape.
  103    103   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SESSIONCREDENTIALS_SCHEMA;
  104    104   
}
  105    105   
impl ::aws_smithy_schema::serde::SerializableStruct for SessionCredentials {
  106    106   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  107    107   
    fn serialize_members(
  108    108   
        &self,
  109    109   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  110    110   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  111    111   
        {
  112    112   
            let val = &self.access_key_id;
  113    113   
            ser.write_string(&SESSIONCREDENTIALS_MEMBER_ACCESS_KEY_ID, val)?;
  114    114   
        }
  115    115   
        {
  116    116   
            let val = &self.secret_access_key;
  117    117   
            ser.write_string(&SESSIONCREDENTIALS_MEMBER_SECRET_ACCESS_KEY, val)?;
  118    118   
        }
  119    119   
        {
  120    120   
            let val = &self.session_token;
  121    121   
            ser.write_string(&SESSIONCREDENTIALS_MEMBER_SESSION_TOKEN, val)?;
  122    122   
        }
  123    123   
        {
  124    124   
            let val = &self.expiration;
  125    125   
            ser.write_timestamp(&SESSIONCREDENTIALS_MEMBER_EXPIRATION, val)?;
  126    126   
        }
  127    127   
        Ok(())
  128    128   
    }
  129    129   
}
  130    130   
impl SessionCredentials {
  131    131   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  132         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  133         -
        deserializer: &mut D,
         132  +
    pub fn deserialize(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  134    134   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  135    135   
        #[allow(unused_variables, unused_mut)]
  136    136   
        let mut builder = Self::builder();
  137    137   
        #[allow(
  138    138   
            unused_variables,
  139    139   
            unreachable_code,
  140    140   
            clippy::single_match,
  141    141   
            clippy::match_single_binding,
  142    142   
            clippy::diverging_sub_expression
  143    143   
        )]
  144         -
        deserializer.read_struct(&SESSIONCREDENTIALS_SCHEMA, (), |_, member, deser| {
         144  +
        deserializer.read_struct(&SESSIONCREDENTIALS_SCHEMA, &mut |member, deser| {
  145    145   
            match member.member_index() {
  146    146   
                Some(0) => {
  147    147   
                    builder.access_key_id = Some(deser.read_string(member)?);
  148    148   
                }
  149    149   
                Some(1) => {
  150    150   
                    builder.secret_access_key = Some(deser.read_string(member)?);
  151    151   
                }
  152    152   
                Some(2) => {
  153    153   
                    builder.session_token = Some(deser.read_string(member)?);
  154    154   
                }
  155    155   
                Some(3) => {
  156    156   
                    builder.expiration = Some(deser.read_timestamp(member)?);
  157    157   
                }
  158    158   
                _ => {}
  159    159   
            }
  160    160   
            Ok(())
  161    161   
        })?;
         162  +
        builder.access_key_id = builder.access_key_id.or(Some(String::new()));
         163  +
        builder.secret_access_key = builder.secret_access_key.or(Some(String::new()));
         164  +
        builder.session_token = builder.session_token.or(Some(String::new()));
         165  +
        builder.expiration = builder.expiration.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  162    166   
        builder
  163    167   
            .build()
  164    168   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  165    169   
    }
  166    170   
}
         171  +
impl SessionCredentials {
         172  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         173  +
    pub fn deserialize_with_response(
         174  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         175  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         176  +
        _status: u16,
         177  +
        _body: &[u8],
         178  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         179  +
        Self::deserialize(deserializer)
         180  +
    }
         181  +
}
  167    182   
impl SessionCredentials {
  168    183   
    /// Creates a new builder-style object to manufacture [`SessionCredentials`](crate::types::SessionCredentials).
  169    184   
    pub fn builder() -> crate::types::builders::SessionCredentialsBuilder {
  170    185   
        crate::types::builders::SessionCredentialsBuilder::default()
  171    186   
    }
  172    187   
}
  173    188   
  174    189   
/// A builder for [`SessionCredentials`](crate::types::SessionCredentials).
  175    190   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  176    191   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_simple_prefix.rs

@@ -1,1 +64,75 @@
   17     17   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   18     18   
    fn serialize_members(
   19     19   
        &self,
   20     20   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   21     21   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   22     22   
        Ok(())
   23     23   
    }
   24     24   
}
   25     25   
impl SimplePrefix {
   26     26   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   27         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   28         -
        deserializer: &mut D,
          27  +
    pub fn deserialize(
          28  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   29     29   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   30     30   
        #[allow(unused_variables, unused_mut)]
   31     31   
        let mut builder = Self::builder();
   32     32   
        #[allow(
   33     33   
            unused_variables,
   34     34   
            unreachable_code,
   35     35   
            clippy::single_match,
   36     36   
            clippy::match_single_binding,
   37     37   
            clippy::diverging_sub_expression
   38     38   
        )]
   39         -
        deserializer.read_struct(&SIMPLEPREFIX_SCHEMA, (), |_, member, deser| {
          39  +
        deserializer.read_struct(&SIMPLEPREFIX_SCHEMA, &mut |member, deser| {
   40     40   
            match member.member_index() {
   41     41   
                _ => {}
   42     42   
            }
   43     43   
            Ok(())
   44     44   
        })?;
   45     45   
        Ok(builder.build())
   46     46   
    }
   47     47   
}
          48  +
impl SimplePrefix {
          49  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          50  +
    pub fn deserialize_with_response(
          51  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          52  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          53  +
        _status: u16,
          54  +
        _body: &[u8],
          55  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          56  +
        Ok(Self::builder().build())
          57  +
    }
          58  +
}
   48     59   
impl SimplePrefix {
   49     60   
    /// Creates a new builder-style object to manufacture [`SimplePrefix`](crate::types::SimplePrefix).
   50     61   
    pub fn builder() -> crate::types::builders::SimplePrefixBuilder {
   51     62   
        crate::types::builders::SimplePrefixBuilder::default()
   52     63   
    }
   53     64   
}
   54     65   
   55     66   
/// A builder for [`SimplePrefix`](crate::types::SimplePrefix).
   56     67   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   57     68   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_source_selection_criteria.rs

@@ -5,5 +133,144 @@
   25     25   
}
   26     26   
static SOURCESELECTIONCRITERIA_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SourceSelectionCriteria", "com.amazonaws.s3", "SourceSelectionCriteria");
   28     28   
static SOURCESELECTIONCRITERIA_MEMBER_SSE_KMS_ENCRYPTED_OBJECTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   29     29   
    ::aws_smithy_schema::ShapeId::from_static(
   30     30   
        "com.amazonaws.s3#SourceSelectionCriteria$SseKmsEncryptedObjects",
   31     31   
        "com.amazonaws.s3",
   32     32   
        "SourceSelectionCriteria",
   33     33   
    ),
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    "sse_kms_encrypted_objects",
          35  +
    "SseKmsEncryptedObjects",
   36     36   
    0,
   37     37   
);
   38     38   
static SOURCESELECTIONCRITERIA_MEMBER_REPLICA_MODIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.s3#SourceSelectionCriteria$ReplicaModifications",
   41     41   
        "com.amazonaws.s3",
   42     42   
        "SourceSelectionCriteria",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::Structure,
   45         -
    "replica_modifications",
          45  +
    "ReplicaModifications",
   46     46   
    1,
   47     47   
);
   48     48   
static SOURCESELECTIONCRITERIA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    SOURCESELECTIONCRITERIA_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[
   52     52   
        &SOURCESELECTIONCRITERIA_MEMBER_SSE_KMS_ENCRYPTED_OBJECTS,
   53     53   
        &SOURCESELECTIONCRITERIA_MEMBER_REPLICA_MODIFICATIONS,
   54     54   
    ],
   55     55   
);
   56     56   
impl SourceSelectionCriteria {
   57     57   
    /// The schema for this shape.
   58     58   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SOURCESELECTIONCRITERIA_SCHEMA;
   59     59   
}
   60     60   
impl ::aws_smithy_schema::serde::SerializableStruct for SourceSelectionCriteria {
   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   
        if let Some(ref val) = self.sse_kms_encrypted_objects {
   67     67   
            ser.write_struct(&SOURCESELECTIONCRITERIA_MEMBER_SSE_KMS_ENCRYPTED_OBJECTS, val)?;
   68     68   
        }
   69     69   
        if let Some(ref val) = self.replica_modifications {
   70     70   
            ser.write_struct(&SOURCESELECTIONCRITERIA_MEMBER_REPLICA_MODIFICATIONS, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl SourceSelectionCriteria {
   76     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     79   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        #[allow(unused_variables, unused_mut)]
   81     81   
        let mut builder = Self::builder();
   82     82   
        #[allow(
   83     83   
            unused_variables,
   84     84   
            unreachable_code,
   85     85   
            clippy::single_match,
   86     86   
            clippy::match_single_binding,
   87     87   
            clippy::diverging_sub_expression
   88     88   
        )]
   89         -
        deserializer.read_struct(&SOURCESELECTIONCRITERIA_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&SOURCESELECTIONCRITERIA_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.sse_kms_encrypted_objects = Some(crate::types::SseKmsEncryptedObjects::deserialize(deser)?);
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.replica_modifications = Some(crate::types::ReplicaModifications::deserialize(deser)?);
   96     96   
                }
   97     97   
                _ => {}
   98     98   
            }
   99     99   
            Ok(())
  100    100   
        })?;
  101    101   
        Ok(builder.build())
  102    102   
    }
  103    103   
}
         104  +
impl SourceSelectionCriteria {
         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  +
}
  104    115   
impl SourceSelectionCriteria {
  105    116   
    /// Creates a new builder-style object to manufacture [`SourceSelectionCriteria`](crate::types::SourceSelectionCriteria).
  106    117   
    pub fn builder() -> crate::types::builders::SourceSelectionCriteriaBuilder {
  107    118   
        crate::types::builders::SourceSelectionCriteriaBuilder::default()
  108    119   
    }
  109    120   
}
  110    121   
  111    122   
/// A builder for [`SourceSelectionCriteria`](crate::types::SourceSelectionCriteria).
  112    123   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  113    124   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_sse_kms_encrypted_objects.rs

@@ -1,1 +107,118 @@
   15     15   
}
   16     16   
static SSEKMSENCRYPTEDOBJECTS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SseKmsEncryptedObjects", "com.amazonaws.s3", "SseKmsEncryptedObjects");
   18     18   
static SSEKMSENCRYPTEDOBJECTS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.s3#SseKmsEncryptedObjects$Status",
   21     21   
        "com.amazonaws.s3",
   22     22   
        "SseKmsEncryptedObjects",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::String,
   25         -
    "status",
          25  +
    "Status",
   26     26   
    0,
   27     27   
);
   28     28   
static SSEKMSENCRYPTEDOBJECTS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   29     29   
    SSEKMSENCRYPTEDOBJECTS_SCHEMA_ID,
   30     30   
    ::aws_smithy_schema::ShapeType::Structure,
   31     31   
    &[&SSEKMSENCRYPTEDOBJECTS_MEMBER_STATUS],
   32     32   
);
   33     33   
impl SseKmsEncryptedObjects {
   34     34   
    /// The schema for this shape.
   35     35   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SSEKMSENCRYPTEDOBJECTS_SCHEMA;
   36     36   
}
   37     37   
impl ::aws_smithy_schema::serde::SerializableStruct for SseKmsEncryptedObjects {
   38     38   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   39     39   
    fn serialize_members(
   40     40   
        &self,
   41     41   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   42     42   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   43     43   
        {
   44     44   
            let val = &self.status;
   45     45   
            ser.write_string(&SSEKMSENCRYPTEDOBJECTS_MEMBER_STATUS, val.as_str())?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl SseKmsEncryptedObjects {
   51     51   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   52         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   53         -
        deserializer: &mut D,
          52  +
    pub fn deserialize(
          53  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   54     54   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   55     55   
        #[allow(unused_variables, unused_mut)]
   56     56   
        let mut builder = Self::builder();
   57     57   
        #[allow(
   58     58   
            unused_variables,
   59     59   
            unreachable_code,
   60     60   
            clippy::single_match,
   61     61   
            clippy::match_single_binding,
   62     62   
            clippy::diverging_sub_expression
   63     63   
        )]
   64         -
        deserializer.read_struct(&SSEKMSENCRYPTEDOBJECTS_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&SSEKMSENCRYPTEDOBJECTS_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.status = Some(crate::types::SseKmsEncryptedObjectsStatus::from(deser.read_string(member)?.as_str()));
   68     68   
                }
   69     69   
                _ => {}
   70     70   
            }
   71     71   
            Ok(())
   72     72   
        })?;
   73     73   
        builder
   74     74   
            .build()
   75     75   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   76     76   
    }
   77     77   
}
          78  +
impl SseKmsEncryptedObjects {
          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 SseKmsEncryptedObjects {
   79     90   
    /// Creates a new builder-style object to manufacture [`SseKmsEncryptedObjects`](crate::types::SseKmsEncryptedObjects).
   80     91   
    pub fn builder() -> crate::types::builders::SseKmsEncryptedObjectsBuilder {
   81     92   
        crate::types::builders::SseKmsEncryptedObjectsBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`SseKmsEncryptedObjects`](crate::types::SseKmsEncryptedObjects).
   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/s3/src/types/_ssekms.rs

@@ -1,1 +109,121 @@
   19     19   
        let mut formatter = f.debug_struct("Ssekms");
   20     20   
        formatter.field("key_id", &"*** Sensitive Data Redacted ***");
   21     21   
        formatter.finish()
   22     22   
    }
   23     23   
}
   24     24   
static SSEKMS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SSEKMS", "com.amazonaws.s3", "SSEKMS");
   26     26   
static SSEKMS_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.s3#SSEKMS$KeyId", "com.amazonaws.s3", "SSEKMS"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "key_id",
          29  +
    "KeyId",
   30     30   
    0,
   31     31   
);
   32     32   
static SSEKMS_SCHEMA: ::aws_smithy_schema::Schema =
   33     33   
    ::aws_smithy_schema::Schema::new_struct(SSEKMS_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[&SSEKMS_MEMBER_KEY_ID])
   34     34   
        .with_xml_name("SSE-KMS");
   35     35   
impl Ssekms {
   36     36   
    /// The schema for this shape.
   37     37   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SSEKMS_SCHEMA;
   38     38   
}
   39     39   
impl ::aws_smithy_schema::serde::SerializableStruct for Ssekms {
   40     40   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     41   
    fn serialize_members(
   42     42   
        &self,
   43     43   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     44   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        {
   46     46   
            let val = &self.key_id;
   47     47   
            ser.write_string(&SSEKMS_MEMBER_KEY_ID, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl Ssekms {
   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(&SSEKMS_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&SSEKMS_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.key_id = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
          75  +
        builder.key_id = builder.key_id.or(Some(String::new()));
   75     76   
        builder
   76     77   
            .build()
   77     78   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   78     79   
    }
   79     80   
}
          81  +
impl Ssekms {
          82  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          83  +
    pub fn deserialize_with_response(
          84  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          85  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          86  +
        _status: u16,
          87  +
        _body: &[u8],
          88  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          89  +
        Self::deserialize(deserializer)
          90  +
    }
          91  +
}
   80     92   
impl Ssekms {
   81     93   
    /// Creates a new builder-style object to manufacture [`Ssekms`](crate::types::Ssekms).
   82     94   
    pub fn builder() -> crate::types::builders::SsekmsBuilder {
   83     95   
        crate::types::builders::SsekmsBuilder::default()
   84     96   
    }
   85     97   
}
   86     98   
   87     99   
/// A builder for [`Ssekms`](crate::types::Ssekms).
   88    100   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
   89    101   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_sses3.rs

@@ -1,1 +63,74 @@
   16     16   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   17     17   
    fn serialize_members(
   18     18   
        &self,
   19     19   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   20     20   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   21     21   
        Ok(())
   22     22   
    }
   23     23   
}
   24     24   
impl Sses3 {
   25     25   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   26         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   27         -
        deserializer: &mut D,
          26  +
    pub fn deserialize(
          27  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   28     28   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   29     29   
        #[allow(unused_variables, unused_mut)]
   30     30   
        let mut builder = Self::builder();
   31     31   
        #[allow(
   32     32   
            unused_variables,
   33     33   
            unreachable_code,
   34     34   
            clippy::single_match,
   35     35   
            clippy::match_single_binding,
   36     36   
            clippy::diverging_sub_expression
   37     37   
        )]
   38         -
        deserializer.read_struct(&SSES3_SCHEMA, (), |_, member, deser| {
          38  +
        deserializer.read_struct(&SSES3_SCHEMA, &mut |member, deser| {
   39     39   
            match member.member_index() {
   40     40   
                _ => {}
   41     41   
            }
   42     42   
            Ok(())
   43     43   
        })?;
   44     44   
        Ok(builder.build())
   45     45   
    }
   46     46   
}
          47  +
impl Sses3 {
          48  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          49  +
    pub fn deserialize_with_response(
          50  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          51  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          52  +
        _status: u16,
          53  +
        _body: &[u8],
          54  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          55  +
        Ok(Self::builder().build())
          56  +
    }
          57  +
}
   47     58   
impl Sses3 {
   48     59   
    /// Creates a new builder-style object to manufacture [`Sses3`](crate::types::Sses3).
   49     60   
    pub fn builder() -> crate::types::builders::Sses3Builder {
   50     61   
        crate::types::builders::Sses3Builder::default()
   51     62   
    }
   52     63   
}
   53     64   
   54     65   
/// A builder for [`Sses3`](crate::types::Sses3).
   55     66   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   56     67   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_stats.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_stats_event.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_storage_class_analysis.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_storage_class_analysis_data_export.rs

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

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_tag.rs

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