AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_throttling_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&THROTTLINGEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ThrottlingException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl ThrottlingException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl ThrottlingException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for ThrottlingException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ThrottlingException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_health_checks.rs

@@ -22,22 +105,116 @@
   42     42   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   43     43   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   44     44   
        if let Some(ref val) = self.message {
   45     45   
            ser.write_string(&TOOMANYHEALTHCHECKS_MEMBER_MESSAGE, val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl TooManyHealthChecks {
   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(&TOOMANYHEALTHCHECKS_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&TOOMANYHEALTHCHECKS_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.message = Some(deser.read_string(member)?);
   68     68   
                }
   69     69   
                _ => {}
   70     70   
            }
   71     71   
            Ok(())
   72     72   
        })?;
   73     73   
        Ok(builder.build())
   74     74   
    }
   75     75   
}
          76  +
impl TooManyHealthChecks {
          77  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          78  +
    pub fn deserialize_with_response(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          80  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          81  +
        _status: u16,
          82  +
        _body: &[u8],
          83  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          84  +
        Self::deserialize(deserializer)
          85  +
    }
          86  +
}
   76     87   
impl TooManyHealthChecks {
   77     88   
    /// Returns the error message.
   78     89   
    pub fn message(&self) -> ::std::option::Option<&str> {
   79     90   
        self.message.as_deref()
   80     91   
    }
   81     92   
}
   82     93   
impl ::std::fmt::Display for TooManyHealthChecks {
   83     94   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     95   
        ::std::write!(f, "TooManyHealthChecks")?;
   85     96   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_hosted_zones.rs

@@ -20,20 +103,114 @@
   40     40   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   41     41   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   42     42   
        if let Some(ref val) = self.message {
   43     43   
            ser.write_string(&TOOMANYHOSTEDZONES_MEMBER_MESSAGE, val)?;
   44     44   
        }
   45     45   
        Ok(())
   46     46   
    }
   47     47   
}
   48     48   
impl TooManyHostedZones {
   49     49   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   50         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   51         -
        deserializer: &mut D,
          50  +
    pub fn deserialize(
          51  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   52     52   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        #[allow(unused_variables, unused_mut)]
   54     54   
        let mut builder = Self::builder();
   55     55   
        #[allow(
   56     56   
            unused_variables,
   57     57   
            unreachable_code,
   58     58   
            clippy::single_match,
   59     59   
            clippy::match_single_binding,
   60     60   
            clippy::diverging_sub_expression
   61     61   
        )]
   62         -
        deserializer.read_struct(&TOOMANYHOSTEDZONES_SCHEMA, (), |_, member, deser| {
          62  +
        deserializer.read_struct(&TOOMANYHOSTEDZONES_SCHEMA, &mut |member, deser| {
   63     63   
            match member.member_index() {
   64     64   
                Some(0) => {
   65     65   
                    builder.message = Some(deser.read_string(member)?);
   66     66   
                }
   67     67   
                _ => {}
   68     68   
            }
   69     69   
            Ok(())
   70     70   
        })?;
   71     71   
        Ok(builder.build())
   72     72   
    }
   73     73   
}
          74  +
impl TooManyHostedZones {
          75  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          76  +
    pub fn deserialize_with_response(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          78  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          79  +
        _status: u16,
          80  +
        _body: &[u8],
          81  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          82  +
        Self::deserialize(deserializer)
          83  +
    }
          84  +
}
   74     85   
impl TooManyHostedZones {
   75     86   
    /// Returns the error message.
   76     87   
    pub fn message(&self) -> ::std::option::Option<&str> {
   77     88   
        self.message.as_deref()
   78     89   
    }
   79     90   
}
   80     91   
impl ::std::fmt::Display for TooManyHostedZones {
   81     92   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   82     93   
        ::std::write!(f, "TooManyHostedZones")?;
   83     94   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_key_signing_keys.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&TOOMANYKEYSIGNINGKEYS_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TooManyKeySigningKeys {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&TOOMANYKEYSIGNINGKEYS_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TOOMANYKEYSIGNINGKEYS_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl TooManyKeySigningKeys {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl TooManyKeySigningKeys {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for TooManyKeySigningKeys {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TooManyKeySigningKeys")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_traffic_policies.rs

@@ -22,22 +105,116 @@
   42     42   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   43     43   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   44     44   
        if let Some(ref val) = self.message {
   45     45   
            ser.write_string(&TOOMANYTRAFFICPOLICIES_MEMBER_MESSAGE, val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl TooManyTrafficPolicies {
   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(&TOOMANYTRAFFICPOLICIES_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&TOOMANYTRAFFICPOLICIES_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.message = Some(deser.read_string(member)?);
   68     68   
                }
   69     69   
                _ => {}
   70     70   
            }
   71     71   
            Ok(())
   72     72   
        })?;
   73     73   
        Ok(builder.build())
   74     74   
    }
   75     75   
}
          76  +
impl TooManyTrafficPolicies {
          77  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          78  +
    pub fn deserialize_with_response(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          80  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          81  +
        _status: u16,
          82  +
        _body: &[u8],
          83  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          84  +
        Self::deserialize(deserializer)
          85  +
    }
          86  +
}
   76     87   
impl TooManyTrafficPolicies {
   77     88   
    /// Returns the error message.
   78     89   
    pub fn message(&self) -> ::std::option::Option<&str> {
   79     90   
        self.message.as_deref()
   80     91   
    }
   81     92   
}
   82     93   
impl ::std::fmt::Display for TooManyTrafficPolicies {
   83     94   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     95   
        ::std::write!(f, "TooManyTrafficPolicies")?;
   85     96   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_traffic_policy_instances.rs

@@ -22,22 +105,116 @@
   42     42   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   43     43   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   44     44   
        if let Some(ref val) = self.message {
   45     45   
            ser.write_string(&TOOMANYTRAFFICPOLICYINSTANCES_MEMBER_MESSAGE, val)?;
   46     46   
        }
   47     47   
        Ok(())
   48     48   
    }
   49     49   
}
   50     50   
impl TooManyTrafficPolicyInstances {
   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(&TOOMANYTRAFFICPOLICYINSTANCES_SCHEMA, (), |_, member, deser| {
          64  +
        deserializer.read_struct(&TOOMANYTRAFFICPOLICYINSTANCES_SCHEMA, &mut |member, deser| {
   65     65   
            match member.member_index() {
   66     66   
                Some(0) => {
   67     67   
                    builder.message = Some(deser.read_string(member)?);
   68     68   
                }
   69     69   
                _ => {}
   70     70   
            }
   71     71   
            Ok(())
   72     72   
        })?;
   73     73   
        Ok(builder.build())
   74     74   
    }
   75     75   
}
          76  +
impl TooManyTrafficPolicyInstances {
          77  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          78  +
    pub fn deserialize_with_response(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          80  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          81  +
        _status: u16,
          82  +
        _body: &[u8],
          83  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          84  +
        Self::deserialize(deserializer)
          85  +
    }
          86  +
}
   76     87   
impl TooManyTrafficPolicyInstances {
   77     88   
    /// Returns the error message.
   78     89   
    pub fn message(&self) -> ::std::option::Option<&str> {
   79     90   
        self.message.as_deref()
   80     91   
    }
   81     92   
}
   82     93   
impl ::std::fmt::Display for TooManyTrafficPolicyInstances {
   83     94   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     95   
        ::std::write!(f, "TooManyTrafficPolicyInstances")?;
   85     96   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_traffic_policy_versions_for_current_policy.rs

@@ -20,20 +103,114 @@
   40     40   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   41     41   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   42     42   
        if let Some(ref val) = self.message {
   43     43   
            ser.write_string(&TOOMANYTRAFFICPOLICYVERSIONSFORCURRENTPOLICY_MEMBER_MESSAGE, val)?;
   44     44   
        }
   45     45   
        Ok(())
   46     46   
    }
   47     47   
}
   48     48   
impl TooManyTrafficPolicyVersionsForCurrentPolicy {
   49     49   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   50         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   51         -
        deserializer: &mut D,
          50  +
    pub fn deserialize(
          51  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   52     52   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        #[allow(unused_variables, unused_mut)]
   54     54   
        let mut builder = Self::builder();
   55     55   
        #[allow(
   56     56   
            unused_variables,
   57     57   
            unreachable_code,
   58     58   
            clippy::single_match,
   59     59   
            clippy::match_single_binding,
   60     60   
            clippy::diverging_sub_expression
   61     61   
        )]
   62         -
        deserializer.read_struct(&TOOMANYTRAFFICPOLICYVERSIONSFORCURRENTPOLICY_SCHEMA, (), |_, member, deser| {
          62  +
        deserializer.read_struct(&TOOMANYTRAFFICPOLICYVERSIONSFORCURRENTPOLICY_SCHEMA, &mut |member, deser| {
   63     63   
            match member.member_index() {
   64     64   
                Some(0) => {
   65     65   
                    builder.message = Some(deser.read_string(member)?);
   66     66   
                }
   67     67   
                _ => {}
   68     68   
            }
   69     69   
            Ok(())
   70     70   
        })?;
   71     71   
        Ok(builder.build())
   72     72   
    }
   73     73   
}
          74  +
impl TooManyTrafficPolicyVersionsForCurrentPolicy {
          75  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          76  +
    pub fn deserialize_with_response(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          78  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          79  +
        _status: u16,
          80  +
        _body: &[u8],
          81  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          82  +
        Self::deserialize(deserializer)
          83  +
    }
          84  +
}
   74     85   
impl TooManyTrafficPolicyVersionsForCurrentPolicy {
   75     86   
    /// Returns the error message.
   76     87   
    pub fn message(&self) -> ::std::option::Option<&str> {
   77     88   
        self.message.as_deref()
   78     89   
    }
   79     90   
}
   80     91   
impl ::std::fmt::Display for TooManyTrafficPolicyVersionsForCurrentPolicy {
   81     92   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   82     93   
        ::std::write!(f, "TooManyTrafficPolicyVersionsForCurrentPolicy")?;
   83     94   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_too_many_vpc_association_authorizations.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&TOOMANYVPCASSOCIATIONAUTHORIZATIONS_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TooManyVpcAssociationAuthorizations {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&TOOMANYVPCASSOCIATIONAUTHORIZATIONS_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TOOMANYVPCASSOCIATIONAUTHORIZATIONS_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl TooManyVpcAssociationAuthorizations {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl TooManyVpcAssociationAuthorizations {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for TooManyVpcAssociationAuthorizations {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TooManyVpcAssociationAuthorizations [TooManyVPCAssociationAuthorizations]")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_traffic_policy_already_exists.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&TRAFFICPOLICYALREADYEXISTS_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TrafficPolicyAlreadyExists {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&TRAFFICPOLICYALREADYEXISTS_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TRAFFICPOLICYALREADYEXISTS_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl TrafficPolicyAlreadyExists {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl TrafficPolicyAlreadyExists {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for TrafficPolicyAlreadyExists {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TrafficPolicyAlreadyExists")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_traffic_policy_in_use.rs

@@ -16,16 +99,110 @@
   36     36   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   37     37   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   38     38   
        if let Some(ref val) = self.message {
   39     39   
            ser.write_string(&TRAFFICPOLICYINUSE_MEMBER_MESSAGE, val)?;
   40     40   
        }
   41     41   
        Ok(())
   42     42   
    }
   43     43   
}
   44     44   
impl TrafficPolicyInUse {
   45     45   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   46         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   47         -
        deserializer: &mut D,
          46  +
    pub fn deserialize(
          47  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   48     48   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   49     49   
        #[allow(unused_variables, unused_mut)]
   50     50   
        let mut builder = Self::builder();
   51     51   
        #[allow(
   52     52   
            unused_variables,
   53     53   
            unreachable_code,
   54     54   
            clippy::single_match,
   55     55   
            clippy::match_single_binding,
   56     56   
            clippy::diverging_sub_expression
   57     57   
        )]
   58         -
        deserializer.read_struct(&TRAFFICPOLICYINUSE_SCHEMA, (), |_, member, deser| {
          58  +
        deserializer.read_struct(&TRAFFICPOLICYINUSE_SCHEMA, &mut |member, deser| {
   59     59   
            match member.member_index() {
   60     60   
                Some(0) => {
   61     61   
                    builder.message = Some(deser.read_string(member)?);
   62     62   
                }
   63     63   
                _ => {}
   64     64   
            }
   65     65   
            Ok(())
   66     66   
        })?;
   67     67   
        Ok(builder.build())
   68     68   
    }
   69     69   
}
          70  +
impl TrafficPolicyInUse {
          71  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          72  +
    pub fn deserialize_with_response(
          73  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          74  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          75  +
        _status: u16,
          76  +
        _body: &[u8],
          77  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          78  +
        Self::deserialize(deserializer)
          79  +
    }
          80  +
}
   70     81   
impl TrafficPolicyInUse {
   71     82   
    /// Returns the error message.
   72     83   
    pub fn message(&self) -> ::std::option::Option<&str> {
   73     84   
        self.message.as_deref()
   74     85   
    }
   75     86   
}
   76     87   
impl ::std::fmt::Display for TrafficPolicyInUse {
   77     88   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   78     89   
        ::std::write!(f, "TrafficPolicyInUse")?;
   79     90   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_traffic_policy_instance_already_exists.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&TRAFFICPOLICYINSTANCEALREADYEXISTS_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl TrafficPolicyInstanceAlreadyExists {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&TRAFFICPOLICYINSTANCEALREADYEXISTS_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&TRAFFICPOLICYINSTANCEALREADYEXISTS_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl TrafficPolicyInstanceAlreadyExists {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl TrafficPolicyInstanceAlreadyExists {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for TrafficPolicyInstanceAlreadyExists {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "TrafficPolicyInstanceAlreadyExists")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_vpc_association_authorization_not_found.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&VPCASSOCIATIONAUTHORIZATIONNOTFOUND_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl VpcAssociationAuthorizationNotFound {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&VPCASSOCIATIONAUTHORIZATIONNOTFOUND_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&VPCASSOCIATIONAUTHORIZATIONNOTFOUND_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl VpcAssociationAuthorizationNotFound {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl VpcAssociationAuthorizationNotFound {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for VpcAssociationAuthorizationNotFound {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "VpcAssociationAuthorizationNotFound [VPCAssociationAuthorizationNotFound]")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/error/_vpc_association_not_found.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&VPCASSOCIATIONNOTFOUND_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl VpcAssociationNotFound {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&VPCASSOCIATIONNOTFOUND_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&VPCASSOCIATIONNOTFOUND_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl VpcAssociationNotFound {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl VpcAssociationNotFound {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for VpcAssociationNotFound {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "VpcAssociationNotFound [VPCAssociationNotFound]")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/s3/Cargo.toml

@@ -29,29 +94,94 @@
   49     49   
path = "../aws-smithy-json"
   50     50   
version = "0.62.6"
   51     51   
   52     52   
[dependencies.aws-smithy-observability]
   53     53   
path = "../aws-smithy-observability"
   54     54   
version = "0.2.6"
   55     55   
   56     56   
[dependencies.aws-smithy-runtime]
   57     57   
path = "../aws-smithy-runtime"
   58     58   
features = ["client"]
   59         -
version = "1.10.3"
          59  +
version = "1.10.4"
   60     60   
   61     61   
[dependencies.aws-smithy-runtime-api]
   62     62   
path = "../aws-smithy-runtime-api"
   63     63   
features = ["client", "http-1x", "http-02x"]
   64         -
version = "1.11.6"
          64  +
version = "1.11.7"
   65     65   
   66     66   
[dependencies.aws-smithy-schema]
   67     67   
path = "../aws-smithy-schema"
   68     68   
version = "1.0.0"
   69     69   
   70     70   
[dependencies.aws-smithy-types]
   71     71   
path = "../aws-smithy-types"
   72     72   
features = ["http-body-1-x"]
   73     73   
version = "1.4.7"
   74     74
@@ -137,137 +202,202 @@
  157    157   
path = "../aws-smithy-mocks"
  158    158   
version = "0.2.6"
  159    159   
  160    160   
[dev-dependencies.aws-smithy-protocol-test]
  161    161   
path = "../aws-smithy-protocol-test"
  162    162   
version = "0.63.14"
  163    163   
  164    164   
[dev-dependencies.aws-smithy-runtime]
  165    165   
path = "../aws-smithy-runtime"
  166    166   
features = ["test-util"]
  167         -
version = "1.10.3"
         167  +
version = "1.10.4"
  168    168   
  169    169   
[dev-dependencies.aws-smithy-runtime-api]
  170    170   
path = "../aws-smithy-runtime-api"
  171    171   
features = ["test-util", "client", "http-1x"]
  172         -
version = "1.11.6"
         172  +
version = "1.11.7"
  173    173   
  174    174   
[dev-dependencies.aws-smithy-types]
  175    175   
path = "../aws-smithy-types"
  176    176   
features = ["http-body-1-x", "test-util"]
  177    177   
version = "1.4.7"
  178    178   
  179    179   
[dev-dependencies.bytes-utils]
  180    180   
version = "0.1.0"
  181    181   
  182    182   
[dev-dependencies.futures-util]

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/abort_multipart_upload.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `AbortMultipartUpload`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AbortMultipartUpload;
    6      6   
impl AbortMultipartUpload {
    7      7   
    /// Creates a new `AbortMultipartUpload`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::abort_multipart_upload::AbortMultipartUploadInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::abort_multipart_upload::AbortMultipartUploadOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::abort_multipart_upload::AbortMultipartUploadInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::abort_multipart_upload::AbortMultipartUploadOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::abort_multipart_upload::AbortMultipartUploadError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                                            ::std::borrow::Cow::Owned(transient_errors)
  137    141   
                                            }).build());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct AbortMultipartUploadResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AbortMultipartUploadResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  156    161   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  157    162   
            force_error = true;
  158    163   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/abort_multipart_upload/_abort_multipart_upload_input.rs

@@ -45,45 +244,304 @@
   65     65   
    "com.amazonaws.s3.synthetic",
   66     66   
    "AbortMultipartUploadInput",
   67     67   
);
   68     68   
static ABORTMULTIPARTUPLOADINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadInput$Bucket",
   71     71   
        "com.amazonaws.s3.synthetic",
   72     72   
        "AbortMultipartUploadInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "bucket",
          75  +
    "Bucket",
   76     76   
    0,
   77     77   
)
   78     78   
.with_http_label();
   79     79   
static ABORTMULTIPARTUPLOADINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadInput$Key",
   82     82   
        "com.amazonaws.s3.synthetic",
   83     83   
        "AbortMultipartUploadInput",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "key",
          86  +
    "Key",
   87     87   
    1,
   88     88   
)
   89     89   
.with_http_label();
   90     90   
static ABORTMULTIPARTUPLOADINPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadInput$UploadId",
   93     93   
        "com.amazonaws.s3.synthetic",
   94     94   
        "AbortMultipartUploadInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "upload_id",
          97  +
    "UploadId",
   98     98   
    2,
   99     99   
)
  100    100   
.with_http_query("uploadId");
  101    101   
static ABORTMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadInput$RequestPayer",
  104    104   
        "com.amazonaws.s3.synthetic",
  105    105   
        "AbortMultipartUploadInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "request_payer",
         108  +
    "RequestPayer",
  109    109   
    3,
  110    110   
)
  111    111   
.with_http_header("x-amz-request-payer");
  112    112   
static ABORTMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static(
  114    114   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadInput$ExpectedBucketOwner",
  115    115   
        "com.amazonaws.s3.synthetic",
  116    116   
        "AbortMultipartUploadInput",
  117    117   
    ),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "expected_bucket_owner",
         119  +
    "ExpectedBucketOwner",
  120    120   
    4,
  121    121   
)
  122    122   
.with_http_header("x-amz-expected-bucket-owner");
  123    123   
static ABORTMULTIPARTUPLOADINPUT_MEMBER_IF_MATCH_INITIATED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadInput$IfMatchInitiatedTime",
  126    126   
        "com.amazonaws.s3.synthetic",
  127    127   
        "AbortMultipartUploadInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::Timestamp,
  130         -
    "if_match_initiated_time",
         130  +
    "IfMatchInitiatedTime",
  131    131   
    5,
  132    132   
)
  133         -
.with_http_header("x-amz-if-match-initiated-time");
         133  +
.with_http_header("x-amz-if-match-initiated-time")
         134  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::HttpDate);
  134    135   
static ABORTMULTIPARTUPLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  135    136   
    ABORTMULTIPARTUPLOADINPUT_SCHEMA_ID,
  136    137   
    ::aws_smithy_schema::ShapeType::Structure,
  137    138   
    &[
  138    139   
        &ABORTMULTIPARTUPLOADINPUT_MEMBER_BUCKET,
  139    140   
        &ABORTMULTIPARTUPLOADINPUT_MEMBER_KEY,
  140    141   
        &ABORTMULTIPARTUPLOADINPUT_MEMBER_UPLOAD_ID,
  141    142   
        &ABORTMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER,
  142    143   
        &ABORTMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  143    144   
        &ABORTMULTIPARTUPLOADINPUT_MEMBER_IF_MATCH_INITIATED_TIME,
  144    145   
    ],
  145         -
);
         146  +
)
         147  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         148  +
    "DELETE",
         149  +
    "/{Key+}?x-id=AbortMultipartUpload",
         150  +
    Some(204),
         151  +
));
  146    152   
impl AbortMultipartUploadInput {
  147    153   
    /// The schema for this shape.
  148    154   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ABORTMULTIPARTUPLOADINPUT_SCHEMA;
  149    155   
}
  150    156   
impl ::aws_smithy_schema::serde::SerializableStruct for AbortMultipartUploadInput {
  151    157   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  152    158   
    fn serialize_members(
  153    159   
        &self,
  154    160   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  155    161   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  156    162   
        if let Some(ref val) = self.bucket {
  157    163   
            ser.write_string(&ABORTMULTIPARTUPLOADINPUT_MEMBER_BUCKET, val)?;
  158    164   
        }
  159    165   
        if let Some(ref val) = self.key {
  160    166   
            ser.write_string(&ABORTMULTIPARTUPLOADINPUT_MEMBER_KEY, val)?;
  161    167   
        }
  162    168   
        if let Some(ref val) = self.upload_id {
  163    169   
            ser.write_string(&ABORTMULTIPARTUPLOADINPUT_MEMBER_UPLOAD_ID, val)?;
  164    170   
        }
  165    171   
        if let Some(ref val) = self.request_payer {
  166    172   
            ser.write_string(&ABORTMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER, val.as_str())?;
  167    173   
        }
  168    174   
        if let Some(ref val) = self.expected_bucket_owner {
  169    175   
            ser.write_string(&ABORTMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
  170    176   
        }
  171    177   
        if let Some(ref val) = self.if_match_initiated_time {
  172    178   
            ser.write_timestamp(&ABORTMULTIPARTUPLOADINPUT_MEMBER_IF_MATCH_INITIATED_TIME, val)?;
  173    179   
        }
  174    180   
        Ok(())
  175    181   
    }
  176    182   
}
  177    183   
impl AbortMultipartUploadInput {
  178    184   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  179         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  180         -
        deserializer: &mut D,
         185  +
    pub fn deserialize(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  181    187   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  182    188   
        #[allow(unused_variables, unused_mut)]
  183    189   
        let mut builder = Self::builder();
  184    190   
        #[allow(
  185    191   
            unused_variables,
  186    192   
            unreachable_code,
  187    193   
            clippy::single_match,
  188    194   
            clippy::match_single_binding,
  189    195   
            clippy::diverging_sub_expression
  190    196   
        )]
  191         -
        deserializer.read_struct(&ABORTMULTIPARTUPLOADINPUT_SCHEMA, (), |_, member, deser| {
         197  +
        deserializer.read_struct(&ABORTMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
  192    198   
            match member.member_index() {
  193    199   
                Some(0) => {
  194    200   
                    builder.bucket = Some(deser.read_string(member)?);
  195    201   
                }
  196    202   
                Some(1) => {
  197    203   
                    builder.key = Some(deser.read_string(member)?);
  198    204   
                }
  199    205   
                Some(2) => {
  200    206   
                    builder.upload_id = Some(deser.read_string(member)?);
  201    207   
                }
  202    208   
                Some(3) => {
  203    209   
                    builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
  204    210   
                }
  205    211   
                Some(4) => {
  206    212   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  207    213   
                }
  208    214   
                Some(5) => {
  209    215   
                    builder.if_match_initiated_time = Some(deser.read_timestamp(member)?);
  210    216   
                }
  211    217   
                _ => {}
  212    218   
            }
  213    219   
            Ok(())
  214    220   
        })?;
         221  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         222  +
        builder.key = builder.key.or(Some(String::new()));
         223  +
        builder.upload_id = builder.upload_id.or(Some(String::new()));
         224  +
        builder
         225  +
            .build()
         226  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         227  +
    }
         228  +
}
         229  +
impl AbortMultipartUploadInput {
         230  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         231  +
    /// Header-bound members are read directly from headers, avoiding runtime
         232  +
    /// member iteration overhead. Body members are read via the deserializer.
         233  +
    pub fn deserialize_with_response(
         234  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         235  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         236  +
        _status: u16,
         237  +
        _body: &[u8],
         238  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         239  +
        #[allow(unused_variables, unused_mut)]
         240  +
        let mut builder = Self::builder();
         241  +
        if let Some(val) = headers.get("x-amz-request-payer") {
         242  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
         243  +
        }
         244  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         245  +
            builder.expected_bucket_owner = Some(val.to_string());
         246  +
        }
         247  +
        if let Some(val) = headers.get("x-amz-if-match-initiated-time") {
         248  +
            builder.if_match_initiated_time = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
         249  +
        }
         250  +
        #[allow(
         251  +
            unused_variables,
         252  +
            unreachable_code,
         253  +
            clippy::single_match,
         254  +
            clippy::match_single_binding,
         255  +
            clippy::diverging_sub_expression
         256  +
        )]
         257  +
        deserializer.read_struct(&ABORTMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
         258  +
            match member.member_index() {
         259  +
                Some(0) => {
         260  +
                    builder.bucket = Some(deser.read_string(member)?);
         261  +
                }
         262  +
                Some(1) => {
         263  +
                    builder.key = Some(deser.read_string(member)?);
         264  +
                }
         265  +
                Some(2) => {
         266  +
                    builder.upload_id = Some(deser.read_string(member)?);
         267  +
                }
         268  +
                Some(3) => { /* read from headers above */ }
         269  +
                Some(4) => { /* read from headers above */ }
         270  +
                Some(5) => { /* read from headers above */ }
         271  +
                _ => {}
         272  +
            }
         273  +
            Ok(())
         274  +
        })?;
  215    275   
        builder
  216    276   
            .build()
  217    277   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  218    278   
    }
  219    279   
}
  220    280   
impl AbortMultipartUploadInput {
  221    281   
    /// Creates a new builder-style object to manufacture [`AbortMultipartUploadInput`](crate::operation::abort_multipart_upload::AbortMultipartUploadInput).
  222    282   
    pub fn builder() -> crate::operation::abort_multipart_upload::builders::AbortMultipartUploadInputBuilder {
  223    283   
        crate::operation::abort_multipart_upload::builders::AbortMultipartUploadInputBuilder::default()
  224    284   
    }