AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

@@ -1,1 +94,94 @@
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.14"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24     24   
features = ["http-02x", "event-stream", "http-1x"]
   25         -
version = "1.7.3"
          25  +
version = "1.7.4"
   26     26   
   27     27   
[dependencies.aws-sigv4]
   28     28   
path = "../aws-sigv4"
   29     29   
version = "1.4.2"
   30     30   
   31     31   
[dependencies.aws-smithy-async]
   32     32   
path = "../aws-smithy-async"
   33     33   
version = "1.2.14"
   34     34   
   35     35   
[dependencies.aws-smithy-checksums]
   36     36   
path = "../aws-smithy-checksums"
   37     37   
version = "0.64.6"
   38     38   
   39     39   
[dependencies.aws-smithy-eventstream]
   40     40   
path = "../aws-smithy-eventstream"
   41     41   
version = "0.60.20"
   42     42   
   43     43   
[dependencies.aws-smithy-http]
   44     44   
path = "../aws-smithy-http"
   45     45   
features = ["event-stream"]
   46     46   
version = "0.63.6"
   47     47   
   48     48   
[dependencies.aws-smithy-json]
   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
@@ -109,109 +202,202 @@
  129    129   
version = "1.9.0"
  130    130   
  131    131   
[dev-dependencies.aws-credential-types]
  132    132   
path = "../aws-credential-types"
  133    133   
features = ["test-util"]
  134    134   
version = "1.2.14"
  135    135   
  136    136   
[dev-dependencies.aws-runtime]
  137    137   
path = "../aws-runtime"
  138    138   
features = ["test-util"]
  139         -
version = "1.7.3"
         139  +
version = "1.7.4"
  140    140   
  141    141   
[dev-dependencies.aws-smithy-async]
  142    142   
path = "../aws-smithy-async"
  143    143   
features = ["test-util"]
  144    144   
version = "1.2.14"
  145    145   
  146    146   
[dev-dependencies.aws-smithy-eventstream]
  147    147   
path = "../aws-smithy-eventstream"
  148    148   
features = ["test-util"]
  149    149   
version = "0.60.20"
  150    150   
  151    151   
[dev-dependencies.aws-smithy-http-client]
  152    152   
path = "../aws-smithy-http-client"
  153    153   
features = ["test-util", "wire-mock", "rustls-ring"]
  154    154   
version = "1.1.12"
  155    155   
  156    156   
[dev-dependencies.aws-smithy-mocks]
  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   
    }

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

@@ -3,3 +113,147 @@
   23     23   
    "com.amazonaws.s3.synthetic",
   24     24   
    "AbortMultipartUploadOutput",
   25     25   
);
   26     26   
static ABORTMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "com.amazonaws.s3.synthetic#AbortMultipartUploadOutput$RequestCharged",
   29     29   
        "com.amazonaws.s3.synthetic",
   30     30   
        "AbortMultipartUploadOutput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "request_charged",
          33  +
    "RequestCharged",
   34     34   
    0,
   35     35   
)
   36     36   
.with_http_header("x-amz-request-charged");
          37  +
static ABORTMULTIPARTUPLOADOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          38  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          39  +
    ::aws_smithy_schema::ShapeType::String,
          40  +
    "request_id",
          41  +
    1,
          42  +
)
          43  +
.with_http_header("x-amzn-requestid");
   37     44   
static ABORTMULTIPARTUPLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   38     45   
    ABORTMULTIPARTUPLOADOUTPUT_SCHEMA_ID,
   39     46   
    ::aws_smithy_schema::ShapeType::Structure,
   40         -
    &[&ABORTMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED],
          47  +
    &[
          48  +
        &ABORTMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED,
          49  +
        &ABORTMULTIPARTUPLOADOUTPUT_MEMBER__REQUEST_ID,
          50  +
    ],
   41     51   
);
   42     52   
impl AbortMultipartUploadOutput {
   43     53   
    /// The schema for this shape.
   44     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ABORTMULTIPARTUPLOADOUTPUT_SCHEMA;
   45     55   
}
   46     56   
impl ::aws_smithy_schema::serde::SerializableStruct for AbortMultipartUploadOutput {
   47     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   48     58   
    fn serialize_members(
   49     59   
        &self,
   50     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   51     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   52     62   
        if let Some(ref val) = self.request_charged {
   53     63   
            ser.write_string(&ABORTMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
   54     64   
        }
   55     65   
        Ok(())
   56     66   
    }
   57     67   
}
   58     68   
impl AbortMultipartUploadOutput {
   59     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   60         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   61         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   62     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   63     73   
        #[allow(unused_variables, unused_mut)]
   64     74   
        let mut builder = Self::builder();
   65     75   
        #[allow(
   66     76   
            unused_variables,
   67     77   
            unreachable_code,
   68     78   
            clippy::single_match,
   69     79   
            clippy::match_single_binding,
   70     80   
            clippy::diverging_sub_expression
   71     81   
        )]
   72         -
        deserializer.read_struct(&ABORTMULTIPARTUPLOADOUTPUT_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&ABORTMULTIPARTUPLOADOUTPUT_SCHEMA, &mut |member, deser| {
   73     83   
            match member.member_index() {
   74     84   
                Some(0) => {
   75     85   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
   76     86   
                }
          87  +
                Some(1) => {
          88  +
                    builder._request_id = Some(deser.read_string(member)?);
          89  +
                }
   77     90   
                _ => {}
   78     91   
            }
   79     92   
            Ok(())
   80     93   
        })?;
   81     94   
        Ok(builder.build())
   82     95   
    }
   83     96   
}
          97  +
impl AbortMultipartUploadOutput {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          99  +
    /// Header-bound members are read directly from headers, avoiding runtime
         100  +
    /// member iteration overhead. Body members are read via the deserializer.
         101  +
    pub fn deserialize_with_response(
         102  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         103  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         104  +
        _status: u16,
         105  +
        _body: &[u8],
         106  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         107  +
        #[allow(unused_variables, unused_mut)]
         108  +
        let mut builder = Self::builder();
         109  +
        if let Some(val) = headers.get("x-amz-request-charged") {
         110  +
            builder.request_charged = Some(crate::types::RequestCharged::from(val));
         111  +
        }
         112  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         113  +
            builder._request_id = Some(val.to_string());
         114  +
        }
         115  +
        Ok(builder.build())
         116  +
    }
         117  +
}
   84    118   
impl crate::s3_request_id::RequestIdExt for AbortMultipartUploadOutput {
   85    119   
    fn extended_request_id(&self) -> Option<&str> {
   86    120   
        self._extended_request_id.as_deref()
   87    121   
    }
   88    122   
}
   89    123   
impl ::aws_types::request_id::RequestId for AbortMultipartUploadOutput {
   90    124   
    fn request_id(&self) -> Option<&str> {
   91    125   
        self._request_id.as_deref()
   92    126   
    }
   93    127   
}

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

@@ -1,1 +40,45 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CompleteMultipartUpload`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CompleteMultipartUpload;
    6      6   
impl CompleteMultipartUpload {
    7      7   
    /// Creates a new `CompleteMultipartUpload`
    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::complete_multipart_upload::CompleteMultipartUploadInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          15  +
        crate::operation::complete_multipart_upload::CompleteMultipartUploadOutput::SCHEMA;
   11     16   
    pub(crate) async fn orchestrate(
   12     17   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     18   
        input: crate::operation::complete_multipart_upload::CompleteMultipartUploadInput,
   14     19   
    ) -> ::std::result::Result<
   15     20   
        crate::operation::complete_multipart_upload::CompleteMultipartUploadOutput,
   16     21   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     22   
            crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
   18     23   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     24   
        >,
   20     25   
    > {
@@ -127,132 +189,195 @@
  147    152   
                .build(),
  148    153   
            );
  149    154   
  150    155   
        ::std::borrow::Cow::Owned(rcb)
  151    156   
    }
  152    157   
}
  153    158   
  154    159   
#[derive(Debug)]
  155    160   
struct CompleteMultipartUploadResponseDeserializer;
  156    161   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CompleteMultipartUploadResponseDeserializer {
  157         -
    fn deserialize_nonstreaming(
         162  +
    fn deserialize_nonstreaming_with_config(
  158    163   
        &self,
  159    164   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         165  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  160    166   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  161    167   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  162    168   
        let headers = response.headers();
  163    169   
        let body = response.body().bytes().expect("body loaded");
  164    170   
        #[allow(unused_mut)]
  165    171   
        let mut force_error = false;
  166    172   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  167    173   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  168    174   
            force_error = true;
  169    175   
        }

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

@@ -161,161 +436,437 @@
  181    181   
    "com.amazonaws.s3.synthetic",
  182    182   
    "CompleteMultipartUploadInput",
  183    183   
);
  184    184   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$Bucket",
  187    187   
        "com.amazonaws.s3.synthetic",
  188    188   
        "CompleteMultipartUploadInput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::String,
  191         -
    "bucket",
         191  +
    "Bucket",
  192    192   
    0,
  193    193   
)
  194    194   
.with_http_label();
  195    195   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static(
  197    197   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$Key",
  198    198   
        "com.amazonaws.s3.synthetic",
  199    199   
        "CompleteMultipartUploadInput",
  200    200   
    ),
  201    201   
    ::aws_smithy_schema::ShapeType::String,
  202         -
    "key",
         202  +
    "Key",
  203    203   
    1,
  204    204   
)
  205    205   
.with_http_label();
  206    206   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_MULTIPART_UPLOAD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$MultipartUpload",
  209    209   
        "com.amazonaws.s3.synthetic",
  210    210   
        "CompleteMultipartUploadInput",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::Structure,
  213         -
    "multipart_upload",
         213  +
    "MultipartUpload",
  214    214   
    2,
  215    215   
)
  216    216   
.with_xml_name("CompleteMultipartUpload")
  217    217   
.with_http_payload();
  218    218   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  219    219   
    ::aws_smithy_schema::ShapeId::from_static(
  220    220   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$UploadId",
  221    221   
        "com.amazonaws.s3.synthetic",
  222    222   
        "CompleteMultipartUploadInput",
  223    223   
    ),
  224    224   
    ::aws_smithy_schema::ShapeType::String,
  225         -
    "upload_id",
         225  +
    "UploadId",
  226    226   
    3,
  227    227   
)
  228    228   
.with_http_query("uploadId");
  229    229   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  230    230   
    ::aws_smithy_schema::ShapeId::from_static(
  231    231   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ChecksumCRC32",
  232    232   
        "com.amazonaws.s3.synthetic",
  233    233   
        "CompleteMultipartUploadInput",
  234    234   
    ),
  235    235   
    ::aws_smithy_schema::ShapeType::String,
  236         -
    "checksum_crc32",
         236  +
    "ChecksumCRC32",
  237    237   
    4,
  238    238   
)
  239    239   
.with_http_header("x-amz-checksum-crc32");
  240    240   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  241    241   
    ::aws_smithy_schema::ShapeId::from_static(
  242    242   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ChecksumCRC32C",
  243    243   
        "com.amazonaws.s3.synthetic",
  244    244   
        "CompleteMultipartUploadInput",
  245    245   
    ),
  246    246   
    ::aws_smithy_schema::ShapeType::String,
  247         -
    "checksum_crc32_c",
         247  +
    "ChecksumCRC32C",
  248    248   
    5,
  249    249   
)
  250    250   
.with_http_header("x-amz-checksum-crc32c");
  251    251   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  252    252   
    ::aws_smithy_schema::ShapeId::from_static(
  253    253   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ChecksumCRC64NVME",
  254    254   
        "com.amazonaws.s3.synthetic",
  255    255   
        "CompleteMultipartUploadInput",
  256    256   
    ),
  257    257   
    ::aws_smithy_schema::ShapeType::String,
  258         -
    "checksum_crc64_nvme",
         258  +
    "ChecksumCRC64NVME",
  259    259   
    6,
  260    260   
)
  261    261   
.with_http_header("x-amz-checksum-crc64nvme");
  262    262   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  263    263   
    ::aws_smithy_schema::ShapeId::from_static(
  264    264   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ChecksumSHA1",
  265    265   
        "com.amazonaws.s3.synthetic",
  266    266   
        "CompleteMultipartUploadInput",
  267    267   
    ),
  268    268   
    ::aws_smithy_schema::ShapeType::String,
  269         -
    "checksum_sha1",
         269  +
    "ChecksumSHA1",
  270    270   
    7,
  271    271   
)
  272    272   
.with_http_header("x-amz-checksum-sha1");
  273    273   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  274    274   
    ::aws_smithy_schema::ShapeId::from_static(
  275    275   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ChecksumSHA256",
  276    276   
        "com.amazonaws.s3.synthetic",
  277    277   
        "CompleteMultipartUploadInput",
  278    278   
    ),
  279    279   
    ::aws_smithy_schema::ShapeType::String,
  280         -
    "checksum_sha256",
         280  +
    "ChecksumSHA256",
  281    281   
    8,
  282    282   
)
  283    283   
.with_http_header("x-amz-checksum-sha256");
  284    284   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static(
  286    286   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ChecksumType",
  287    287   
        "com.amazonaws.s3.synthetic",
  288    288   
        "CompleteMultipartUploadInput",
  289    289   
    ),
  290    290   
    ::aws_smithy_schema::ShapeType::String,
  291         -
    "checksum_type",
         291  +
    "ChecksumType",
  292    292   
    9,
  293    293   
)
  294    294   
.with_http_header("x-amz-checksum-type");
  295    295   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_MPU_OBJECT_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  296    296   
    ::aws_smithy_schema::ShapeId::from_static(
  297    297   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$MpuObjectSize",
  298    298   
        "com.amazonaws.s3.synthetic",
  299    299   
        "CompleteMultipartUploadInput",
  300    300   
    ),
  301    301   
    ::aws_smithy_schema::ShapeType::Long,
  302         -
    "mpu_object_size",
         302  +
    "MpuObjectSize",
  303    303   
    10,
  304    304   
)
  305    305   
.with_http_header("x-amz-mp-object-size");
  306    306   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  307    307   
    ::aws_smithy_schema::ShapeId::from_static(
  308    308   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$RequestPayer",
  309    309   
        "com.amazonaws.s3.synthetic",
  310    310   
        "CompleteMultipartUploadInput",
  311    311   
    ),
  312    312   
    ::aws_smithy_schema::ShapeType::String,
  313         -
    "request_payer",
         313  +
    "RequestPayer",
  314    314   
    11,
  315    315   
)
  316    316   
.with_http_header("x-amz-request-payer");
  317    317   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  318    318   
    ::aws_smithy_schema::ShapeId::from_static(
  319    319   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$ExpectedBucketOwner",
  320    320   
        "com.amazonaws.s3.synthetic",
  321    321   
        "CompleteMultipartUploadInput",
  322    322   
    ),
  323    323   
    ::aws_smithy_schema::ShapeType::String,
  324         -
    "expected_bucket_owner",
         324  +
    "ExpectedBucketOwner",
  325    325   
    12,
  326    326   
)
  327    327   
.with_http_header("x-amz-expected-bucket-owner");
  328    328   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  329    329   
    ::aws_smithy_schema::ShapeId::from_static(
  330    330   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$IfMatch",
  331    331   
        "com.amazonaws.s3.synthetic",
  332    332   
        "CompleteMultipartUploadInput",
  333    333   
    ),
  334    334   
    ::aws_smithy_schema::ShapeType::String,
  335         -
    "if_match",
         335  +
    "IfMatch",
  336    336   
    13,
  337    337   
)
  338    338   
.with_http_header("If-Match");
  339    339   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  340    340   
    ::aws_smithy_schema::ShapeId::from_static(
  341    341   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$IfNoneMatch",
  342    342   
        "com.amazonaws.s3.synthetic",
  343    343   
        "CompleteMultipartUploadInput",
  344    344   
    ),
  345    345   
    ::aws_smithy_schema::ShapeType::String,
  346         -
    "if_none_match",
         346  +
    "IfNoneMatch",
  347    347   
    14,
  348    348   
)
  349    349   
.with_http_header("If-None-Match");
  350    350   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  351    351   
    ::aws_smithy_schema::ShapeId::from_static(
  352    352   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$SSECustomerAlgorithm",
  353    353   
        "com.amazonaws.s3.synthetic",
  354    354   
        "CompleteMultipartUploadInput",
  355    355   
    ),
  356    356   
    ::aws_smithy_schema::ShapeType::String,
  357         -
    "sse_customer_algorithm",
         357  +
    "SSECustomerAlgorithm",
  358    358   
    15,
  359    359   
)
  360    360   
.with_http_header("x-amz-server-side-encryption-customer-algorithm");
  361    361   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  362    362   
    ::aws_smithy_schema::ShapeId::from_static(
  363    363   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$SSECustomerKey",
  364    364   
        "com.amazonaws.s3.synthetic",
  365    365   
        "CompleteMultipartUploadInput",
  366    366   
    ),
  367    367   
    ::aws_smithy_schema::ShapeType::String,
  368         -
    "sse_customer_key",
         368  +
    "SSECustomerKey",
  369    369   
    16,
  370    370   
)
  371    371   
.with_http_header("x-amz-server-side-encryption-customer-key");
  372    372   
static COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  373    373   
    ::aws_smithy_schema::ShapeId::from_static(
  374    374   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadInput$SSECustomerKeyMD5",
  375    375   
        "com.amazonaws.s3.synthetic",
  376    376   
        "CompleteMultipartUploadInput",
  377    377   
    ),
  378    378   
    ::aws_smithy_schema::ShapeType::String,
  379         -
    "sse_customer_key_md5",
         379  +
    "SSECustomerKeyMD5",
  380    380   
    17,
  381    381   
)
  382    382   
.with_http_header("x-amz-server-side-encryption-customer-key-MD5");
  383    383   
static COMPLETEMULTIPARTUPLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  384    384   
    COMPLETEMULTIPARTUPLOADINPUT_SCHEMA_ID,
  385    385   
    ::aws_smithy_schema::ShapeType::Structure,
  386    386   
    &[
  387    387   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_BUCKET,
  388    388   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_KEY,
  389    389   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_MULTIPART_UPLOAD,
  390    390   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_UPLOAD_ID,
  391    391   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_CRC32,
  392    392   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_CRC32_C,
  393    393   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_CRC64_NVME,
  394    394   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_SHA1,
  395    395   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_SHA256,
  396    396   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_CHECKSUM_TYPE,
  397    397   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_MPU_OBJECT_SIZE,
  398    398   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_REQUEST_PAYER,
  399    399   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
  400    400   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_IF_MATCH,
  401    401   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_IF_NONE_MATCH,
  402    402   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
  403    403   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY,
  404    404   
        &COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
  405    405   
    ],
  406         -
);
         406  +
)
         407  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/{Key+}", None));
  407    408   
impl CompleteMultipartUploadInput {
  408    409   
    /// The schema for this shape.
  409    410   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLETEMULTIPARTUPLOADINPUT_SCHEMA;
  410    411   
}
  411    412   
impl ::aws_smithy_schema::serde::SerializableStruct for CompleteMultipartUploadInput {
  412    413   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  413    414   
    fn serialize_members(
  414    415   
        &self,
  415    416   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  416    417   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -446,447 +577,643 @@
  466    467   
            ser.write_string(&COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY, val)?;
  467    468   
        }
  468    469   
        if let Some(ref val) = self.sse_customer_key_md5 {
  469    470   
            ser.write_string(&COMPLETEMULTIPARTUPLOADINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
  470    471   
        }
  471    472   
        Ok(())
  472    473   
    }
  473    474   
}
  474    475   
impl CompleteMultipartUploadInput {
  475    476   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  476         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  477         -
        deserializer: &mut D,
         477  +
    pub fn deserialize(
         478  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  478    479   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  479    480   
        #[allow(unused_variables, unused_mut)]
  480    481   
        let mut builder = Self::builder();
  481    482   
        #[allow(
  482    483   
            unused_variables,
  483    484   
            unreachable_code,
  484    485   
            clippy::single_match,
  485    486   
            clippy::match_single_binding,
  486    487   
            clippy::diverging_sub_expression
  487    488   
        )]
  488         -
        deserializer.read_struct(&COMPLETEMULTIPARTUPLOADINPUT_SCHEMA, (), |_, member, deser| {
         489  +
        deserializer.read_struct(&COMPLETEMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
  489    490   
            match member.member_index() {
  490    491   
                Some(0) => {
  491    492   
                    builder.bucket = Some(deser.read_string(member)?);
  492    493   
                }
  493    494   
                Some(1) => {
  494    495   
                    builder.key = Some(deser.read_string(member)?);
  495    496   
                }
  496    497   
                Some(2) => {
  497    498   
                    builder.multipart_upload = Some(crate::types::CompletedMultipartUpload::deserialize(deser)?);
  498    499   
                }
  499    500   
                Some(3) => {
  500    501   
                    builder.upload_id = Some(deser.read_string(member)?);
  501    502   
                }
  502    503   
                Some(4) => {
  503    504   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  504    505   
                }
  505    506   
                Some(5) => {
  506    507   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  507    508   
                }
  508    509   
                Some(6) => {
  509    510   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  510    511   
                }
  511    512   
                Some(7) => {
  512    513   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  513    514   
                }
  514    515   
                Some(8) => {
  515    516   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  516    517   
                }
  517    518   
                Some(9) => {
  518    519   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  519    520   
                }
  520    521   
                Some(10) => {
  521    522   
                    builder.mpu_object_size = Some(deser.read_long(member)?);
  522    523   
                }
  523    524   
                Some(11) => {
  524    525   
                    builder.request_payer = Some(crate::types::RequestPayer::from(deser.read_string(member)?.as_str()));
  525    526   
                }
  526    527   
                Some(12) => {
  527    528   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
  528    529   
                }
  529    530   
                Some(13) => {
  530    531   
                    builder.if_match = Some(deser.read_string(member)?);
  531    532   
                }
  532    533   
                Some(14) => {
  533    534   
                    builder.if_none_match = Some(deser.read_string(member)?);
  534    535   
                }
  535    536   
                Some(15) => {
  536    537   
                    builder.sse_customer_algorithm = Some(deser.read_string(member)?);
  537    538   
                }
  538    539   
                Some(16) => {
  539    540   
                    builder.sse_customer_key = Some(deser.read_string(member)?);
  540    541   
                }
  541    542   
                Some(17) => {
  542    543   
                    builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
  543    544   
                }
  544    545   
                _ => {}
  545    546   
            }
  546    547   
            Ok(())
  547    548   
        })?;
         549  +
        builder.bucket = builder.bucket.or(Some(String::new()));
         550  +
        builder.key = builder.key.or(Some(String::new()));
         551  +
        builder.upload_id = builder.upload_id.or(Some(String::new()));
         552  +
        builder
         553  +
            .build()
         554  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         555  +
    }
         556  +
}
         557  +
impl CompleteMultipartUploadInput {
         558  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         559  +
    /// Header-bound members are read directly from headers, avoiding runtime
         560  +
    /// member iteration overhead. Body members are read via the deserializer.
         561  +
    pub fn deserialize_with_response(
         562  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         563  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         564  +
        _status: u16,
         565  +
        body: &[u8],
         566  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         567  +
        #[allow(unused_variables, unused_mut)]
         568  +
        let mut builder = Self::builder();
         569  +
        if let Some(val) = headers.get("x-amz-checksum-crc32") {
         570  +
            builder.checksum_crc32 = Some(val.to_string());
         571  +
        }
         572  +
        if let Some(val) = headers.get("x-amz-checksum-crc32c") {
         573  +
            builder.checksum_crc32_c = Some(val.to_string());
         574  +
        }
         575  +
        if let Some(val) = headers.get("x-amz-checksum-crc64nvme") {
         576  +
            builder.checksum_crc64_nvme = Some(val.to_string());
         577  +
        }
         578  +
        if let Some(val) = headers.get("x-amz-checksum-sha1") {
         579  +
            builder.checksum_sha1 = Some(val.to_string());
         580  +
        }
         581  +
        if let Some(val) = headers.get("x-amz-checksum-sha256") {
         582  +
            builder.checksum_sha256 = Some(val.to_string());
         583  +
        }
         584  +
        if let Some(val) = headers.get("x-amz-checksum-type") {
         585  +
            builder.checksum_type = Some(crate::types::ChecksumType::from(val));
         586  +
        }
         587  +
        if let Some(val) = headers.get("x-amz-mp-object-size") {
         588  +
            builder.mpu_object_size = val.parse::<i64>().ok();
         589  +
        }
         590  +
        if let Some(val) = headers.get("x-amz-request-payer") {
         591  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
         592  +
        }
         593  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
         594  +
            builder.expected_bucket_owner = Some(val.to_string());
         595  +
        }
         596  +
        if let Some(val) = headers.get("If-Match") {
         597  +
            builder.if_match = Some(val.to_string());
         598  +
        }
         599  +
        if let Some(val) = headers.get("If-None-Match") {
         600  +
            builder.if_none_match = Some(val.to_string());
         601  +
        }
         602  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
         603  +
            builder.sse_customer_algorithm = Some(val.to_string());
         604  +
        }
         605  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
         606  +
            builder.sse_customer_key = Some(val.to_string());
         607  +
        }
         608  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
         609  +
            builder.sse_customer_key_md5 = Some(val.to_string());
         610  +
        }
         611  +
        if !body.is_empty() {
         612  +
            builder.multipart_upload = Some(crate::types::CompletedMultipartUpload::deserialize(deserializer)?);
         613  +
        }
  548    614   
        builder
  549    615   
            .build()
  550    616   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  551    617   
    }
  552    618   
}
  553    619   
impl CompleteMultipartUploadInput {
  554    620   
    /// Creates a new builder-style object to manufacture [`CompleteMultipartUploadInput`](crate::operation::complete_multipart_upload::CompleteMultipartUploadInput).
  555    621   
    pub fn builder() -> crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadInputBuilder {
  556    622   
        crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadInputBuilder::default()
  557    623   
    }

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

@@ -135,135 +373,381 @@
  155    155   
    "com.amazonaws.s3.synthetic",
  156    156   
    "CompleteMultipartUploadOutput",
  157    157   
);
  158    158   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$Location",
  161    161   
        "com.amazonaws.s3.synthetic",
  162    162   
        "CompleteMultipartUploadOutput",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::String,
  165         -
    "location",
         165  +
    "Location",
  166    166   
    0,
  167    167   
);
  168    168   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$Bucket",
  171    171   
        "com.amazonaws.s3.synthetic",
  172    172   
        "CompleteMultipartUploadOutput",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::String,
  175         -
    "bucket",
         175  +
    "Bucket",
  176    176   
    1,
  177    177   
);
  178    178   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$Key",
  181    181   
        "com.amazonaws.s3.synthetic",
  182    182   
        "CompleteMultipartUploadOutput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "key",
         185  +
    "Key",
  186    186   
    2,
  187    187   
);
  188    188   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$Expiration",
  191    191   
        "com.amazonaws.s3.synthetic",
  192    192   
        "CompleteMultipartUploadOutput",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "expiration",
         195  +
    "Expiration",
  196    196   
    3,
  197    197   
)
  198    198   
.with_http_header("x-amz-expiration");
  199    199   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_E_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ETag",
  202    202   
        "com.amazonaws.s3.synthetic",
  203    203   
        "CompleteMultipartUploadOutput",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::String,
  206         -
    "e_tag",
         206  +
    "ETag",
  207    207   
    4,
  208    208   
);
  209    209   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_CRC32: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ChecksumCRC32",
  212    212   
        "com.amazonaws.s3.synthetic",
  213    213   
        "CompleteMultipartUploadOutput",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::String,
  216         -
    "checksum_crc32",
         216  +
    "ChecksumCRC32",
  217    217   
    5,
  218    218   
);
  219    219   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_CRC32_C: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static(
  221    221   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ChecksumCRC32C",
  222    222   
        "com.amazonaws.s3.synthetic",
  223    223   
        "CompleteMultipartUploadOutput",
  224    224   
    ),
  225    225   
    ::aws_smithy_schema::ShapeType::String,
  226         -
    "checksum_crc32_c",
         226  +
    "ChecksumCRC32C",
  227    227   
    6,
  228    228   
);
  229    229   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_CRC64_NVME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  230    230   
    ::aws_smithy_schema::ShapeId::from_static(
  231    231   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ChecksumCRC64NVME",
  232    232   
        "com.amazonaws.s3.synthetic",
  233    233   
        "CompleteMultipartUploadOutput",
  234    234   
    ),
  235    235   
    ::aws_smithy_schema::ShapeType::String,
  236         -
    "checksum_crc64_nvme",
         236  +
    "ChecksumCRC64NVME",
  237    237   
    7,
  238    238   
);
  239    239   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_SHA1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  240    240   
    ::aws_smithy_schema::ShapeId::from_static(
  241    241   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ChecksumSHA1",
  242    242   
        "com.amazonaws.s3.synthetic",
  243    243   
        "CompleteMultipartUploadOutput",
  244    244   
    ),
  245    245   
    ::aws_smithy_schema::ShapeType::String,
  246         -
    "checksum_sha1",
         246  +
    "ChecksumSHA1",
  247    247   
    8,
  248    248   
);
  249    249   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ChecksumSHA256",
  252    252   
        "com.amazonaws.s3.synthetic",
  253    253   
        "CompleteMultipartUploadOutput",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::String,
  256         -
    "checksum_sha256",
         256  +
    "ChecksumSHA256",
  257    257   
    9,
  258    258   
);
  259    259   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static(
  261    261   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ChecksumType",
  262    262   
        "com.amazonaws.s3.synthetic",
  263    263   
        "CompleteMultipartUploadOutput",
  264    264   
    ),
  265    265   
    ::aws_smithy_schema::ShapeType::String,
  266         -
    "checksum_type",
         266  +
    "ChecksumType",
  267    267   
    10,
  268    268   
);
  269    269   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  270    270   
    ::aws_smithy_schema::ShapeId::from_static(
  271    271   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$ServerSideEncryption",
  272    272   
        "com.amazonaws.s3.synthetic",
  273    273   
        "CompleteMultipartUploadOutput",
  274    274   
    ),
  275    275   
    ::aws_smithy_schema::ShapeType::String,
  276         -
    "server_side_encryption",
         276  +
    "ServerSideEncryption",
  277    277   
    11,
  278    278   
)
  279    279   
.with_http_header("x-amz-server-side-encryption");
  280    280   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  281    281   
    ::aws_smithy_schema::ShapeId::from_static(
  282    282   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$VersionId",
  283    283   
        "com.amazonaws.s3.synthetic",
  284    284   
        "CompleteMultipartUploadOutput",
  285    285   
    ),
  286    286   
    ::aws_smithy_schema::ShapeType::String,
  287         -
    "version_id",
         287  +
    "VersionId",
  288    288   
    12,
  289    289   
)
  290    290   
.with_http_header("x-amz-version-id");
  291    291   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  292    292   
    ::aws_smithy_schema::ShapeId::from_static(
  293    293   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$SSEKMSKeyId",
  294    294   
        "com.amazonaws.s3.synthetic",
  295    295   
        "CompleteMultipartUploadOutput",
  296    296   
    ),
  297    297   
    ::aws_smithy_schema::ShapeType::String,
  298         -
    "ssekms_key_id",
         298  +
    "SSEKMSKeyId",
  299    299   
    13,
  300    300   
)
  301    301   
.with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
  302    302   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  303    303   
    ::aws_smithy_schema::ShapeId::from_static(
  304    304   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$BucketKeyEnabled",
  305    305   
        "com.amazonaws.s3.synthetic",
  306    306   
        "CompleteMultipartUploadOutput",
  307    307   
    ),
  308    308   
    ::aws_smithy_schema::ShapeType::Boolean,
  309         -
    "bucket_key_enabled",
         309  +
    "BucketKeyEnabled",
  310    310   
    14,
  311    311   
)
  312    312   
.with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
  313    313   
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  314    314   
    ::aws_smithy_schema::ShapeId::from_static(
  315    315   
        "com.amazonaws.s3.synthetic#CompleteMultipartUploadOutput$RequestCharged",
  316    316   
        "com.amazonaws.s3.synthetic",
  317    317   
        "CompleteMultipartUploadOutput",
  318    318   
    ),
  319    319   
    ::aws_smithy_schema::ShapeType::String,
  320         -
    "request_charged",
         320  +
    "RequestCharged",
  321    321   
    15,
  322    322   
)
  323    323   
.with_http_header("x-amz-request-charged");
         324  +
static COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         325  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         326  +
    ::aws_smithy_schema::ShapeType::String,
         327  +
    "request_id",
         328  +
    16,
         329  +
)
         330  +
.with_http_header("x-amzn-requestid");
  324    331   
static COMPLETEMULTIPARTUPLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  325    332   
    COMPLETEMULTIPARTUPLOADOUTPUT_SCHEMA_ID,
  326    333   
    ::aws_smithy_schema::ShapeType::Structure,
  327    334   
    &[
  328    335   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_LOCATION,
  329    336   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET,
  330    337   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_KEY,
  331    338   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_EXPIRATION,
  332    339   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_E_TAG,
  333    340   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_CRC32,
  334    341   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_CRC32_C,
  335    342   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_CRC64_NVME,
  336    343   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_SHA1,
  337    344   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_SHA256,
  338    345   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_CHECKSUM_TYPE,
  339    346   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
  340    347   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_VERSION_ID,
  341    348   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_SSEKMS_KEY_ID,
  342    349   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
  343    350   
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED,
         351  +
        &COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER__REQUEST_ID,
  344    352   
    ],
  345    353   
)
  346    354   
.with_xml_name("CompleteMultipartUploadResult");
  347    355   
impl CompleteMultipartUploadOutput {
  348    356   
    /// The schema for this shape.
  349    357   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COMPLETEMULTIPARTUPLOADOUTPUT_SCHEMA;
  350    358   
}
  351    359   
impl ::aws_smithy_schema::serde::SerializableStruct for CompleteMultipartUploadOutput {
  352    360   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  353    361   
    fn serialize_members(
@@ -380,388 +501,597 @@
  400    408   
            ser.write_boolean(&COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
  401    409   
        }
  402    410   
        if let Some(ref val) = self.request_charged {
  403    411   
            ser.write_string(&COMPLETEMULTIPARTUPLOADOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
  404    412   
        }
  405    413   
        Ok(())
  406    414   
    }
  407    415   
}
  408    416   
impl CompleteMultipartUploadOutput {
  409    417   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  410         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  411         -
        deserializer: &mut D,
         418  +
    pub fn deserialize(
         419  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  412    420   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  413    421   
        #[allow(unused_variables, unused_mut)]
  414    422   
        let mut builder = Self::builder();
  415    423   
        #[allow(
  416    424   
            unused_variables,
  417    425   
            unreachable_code,
  418    426   
            clippy::single_match,
  419    427   
            clippy::match_single_binding,
  420    428   
            clippy::diverging_sub_expression
  421    429   
        )]
  422         -
        deserializer.read_struct(&COMPLETEMULTIPARTUPLOADOUTPUT_SCHEMA, (), |_, member, deser| {
         430  +
        deserializer.read_struct(&COMPLETEMULTIPARTUPLOADOUTPUT_SCHEMA, &mut |member, deser| {
  423    431   
            match member.member_index() {
  424    432   
                Some(0) => {
  425    433   
                    builder.location = Some(deser.read_string(member)?);
  426    434   
                }
  427    435   
                Some(1) => {
  428    436   
                    builder.bucket = Some(deser.read_string(member)?);
  429    437   
                }
  430    438   
                Some(2) => {
  431    439   
                    builder.key = Some(deser.read_string(member)?);
  432    440   
                }
  433    441   
                Some(3) => {
  434    442   
                    builder.expiration = Some(deser.read_string(member)?);
  435    443   
                }
  436    444   
                Some(4) => {
  437    445   
                    builder.e_tag = Some(deser.read_string(member)?);
  438    446   
                }
  439    447   
                Some(5) => {
  440    448   
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
  441    449   
                }
  442    450   
                Some(6) => {
  443    451   
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
  444    452   
                }
  445    453   
                Some(7) => {
  446    454   
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
  447    455   
                }
  448    456   
                Some(8) => {
  449    457   
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
  450    458   
                }
  451    459   
                Some(9) => {
  452    460   
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
  453    461   
                }
  454    462   
                Some(10) => {
  455    463   
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
  456    464   
                }
  457    465   
                Some(11) => {
  458    466   
                    builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
  459    467   
                }
  460    468   
                Some(12) => {
  461    469   
                    builder.version_id = Some(deser.read_string(member)?);
  462    470   
                }
  463    471   
                Some(13) => {
  464    472   
                    builder.ssekms_key_id = Some(deser.read_string(member)?);
  465    473   
                }
  466    474   
                Some(14) => {
  467    475   
                    builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
  468    476   
                }
  469    477   
                Some(15) => {
  470    478   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
  471    479   
                }
         480  +
                Some(16) => {
         481  +
                    builder._request_id = Some(deser.read_string(member)?);
         482  +
                }
         483  +
                _ => {}
         484  +
            }
         485  +
            Ok(())
         486  +
        })?;
         487  +
        Ok(builder.build())
         488  +
    }
         489  +
}
         490  +
impl CompleteMultipartUploadOutput {
         491  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         492  +
    /// Header-bound members are read directly from headers, avoiding runtime
         493  +
    /// member iteration overhead. Body members are read via the deserializer.
         494  +
    pub fn deserialize_with_response(
         495  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         496  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         497  +
        _status: u16,
         498  +
        _body: &[u8],
         499  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         500  +
        #[allow(unused_variables, unused_mut)]
         501  +
        let mut builder = Self::builder();
         502  +
        if let Some(val) = headers.get("x-amz-expiration") {
         503  +
            builder.expiration = Some(val.to_string());
         504  +
        }
         505  +
        if let Some(val) = headers.get("x-amz-server-side-encryption") {
         506  +
            builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
         507  +
        }
         508  +
        if let Some(val) = headers.get("x-amz-version-id") {
         509  +
            builder.version_id = Some(val.to_string());
         510  +
        }
         511  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
         512  +
            builder.ssekms_key_id = Some(val.to_string());
         513  +
        }
         514  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
         515  +
            builder.bucket_key_enabled = val.parse::<bool>().ok();
         516  +
        }
         517  +
        if let Some(val) = headers.get("x-amz-request-charged") {
         518  +
            builder.request_charged = Some(crate::types::RequestCharged::from(val));
         519  +
        }
         520  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         521  +
            builder._request_id = Some(val.to_string());
         522  +
        }
         523  +
        #[allow(
         524  +
            unused_variables,
         525  +
            unreachable_code,
         526  +
            clippy::single_match,
         527  +
            clippy::match_single_binding,
         528  +
            clippy::diverging_sub_expression
         529  +
        )]
         530  +
        deserializer.read_struct(&COMPLETEMULTIPARTUPLOADOUTPUT_SCHEMA, &mut |member, deser| {
         531  +
            match member.member_index() {
         532  +
                Some(0) => {
         533  +
                    builder.location = Some(deser.read_string(member)?);
         534  +
                }
         535  +
                Some(1) => {
         536  +
                    builder.bucket = Some(deser.read_string(member)?);
         537  +
                }
         538  +
                Some(2) => {
         539  +
                    builder.key = Some(deser.read_string(member)?);
         540  +
                }
         541  +
                Some(3) => { /* read from headers above */ }
         542  +
                Some(4) => {
         543  +
                    builder.e_tag = Some(deser.read_string(member)?);
         544  +
                }
         545  +
                Some(5) => {
         546  +
                    builder.checksum_crc32 = Some(deser.read_string(member)?);
         547  +
                }
         548  +
                Some(6) => {
         549  +
                    builder.checksum_crc32_c = Some(deser.read_string(member)?);
         550  +
                }
         551  +
                Some(7) => {
         552  +
                    builder.checksum_crc64_nvme = Some(deser.read_string(member)?);
         553  +
                }
         554  +
                Some(8) => {
         555  +
                    builder.checksum_sha1 = Some(deser.read_string(member)?);
         556  +
                }
         557  +
                Some(9) => {
         558  +
                    builder.checksum_sha256 = Some(deser.read_string(member)?);
         559  +
                }
         560  +
                Some(10) => {
         561  +
                    builder.checksum_type = Some(crate::types::ChecksumType::from(deser.read_string(member)?.as_str()));
         562  +
                }
         563  +
                Some(11) => { /* read from headers above */ }
         564  +
                Some(12) => { /* read from headers above */ }
         565  +
                Some(13) => { /* read from headers above */ }
         566  +
                Some(14) => { /* read from headers above */ }
         567  +
                Some(15) => { /* read from headers above */ }
  472    568   
                _ => {}
  473    569   
            }
  474    570   
            Ok(())
  475    571   
        })?;
  476    572   
        Ok(builder.build())
  477    573   
    }
  478    574   
}
  479    575   
impl crate::s3_request_id::RequestIdExt for CompleteMultipartUploadOutput {
  480    576   
    fn extended_request_id(&self) -> Option<&str> {
  481    577   
        self._extended_request_id.as_deref()

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/copy_object.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 `CopyObject`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CopyObject;
    6      6   
impl CopyObject {
    7      7   
    /// Creates a new `CopyObject`
    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::copy_object::CopyObjectInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::copy_object::CopyObjectOutput::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::copy_object::CopyObjectInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::copy_object::CopyObjectOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::copy_object::CopyObjectError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -121,125 +183,188 @@
  141    145   
                    .build(),
  142    146   
            );
  143    147   
  144    148   
        ::std::borrow::Cow::Owned(rcb)
  145    149   
    }
  146    150   
}
  147    151   
  148    152   
#[derive(Debug)]
  149    153   
struct CopyObjectResponseDeserializer;
  150    154   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CopyObjectResponseDeserializer {
  151         -
    fn deserialize_nonstreaming(
         155  +
    fn deserialize_nonstreaming_with_config(
  152    156   
        &self,
  153    157   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         158  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  154    159   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  155    160   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  156    161   
        let headers = response.headers();
  157    162   
        let body = response.body().bytes().expect("body loaded");
  158    163   
        #[allow(unused_mut)]
  159    164   
        let mut force_error = false;
  160    165   
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  161    166   
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  162    167   
            force_error = true;
  163    168   
        }

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

@@ -768,768 +1342,1344 @@
  788    788   
    "com.amazonaws.s3.synthetic",
  789    789   
    "CopyObjectInput",
  790    790   
);
  791    791   
static COPYOBJECTINPUT_MEMBER_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  792    792   
    ::aws_smithy_schema::ShapeId::from_static(
  793    793   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ACL",
  794    794   
        "com.amazonaws.s3.synthetic",
  795    795   
        "CopyObjectInput",
  796    796   
    ),
  797    797   
    ::aws_smithy_schema::ShapeType::String,
  798         -
    "acl",
         798  +
    "ACL",
  799    799   
    0,
  800    800   
)
  801    801   
.with_http_header("x-amz-acl");
  802    802   
static COPYOBJECTINPUT_MEMBER_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  803    803   
    ::aws_smithy_schema::ShapeId::from_static(
  804    804   
        "com.amazonaws.s3.synthetic#CopyObjectInput$Bucket",
  805    805   
        "com.amazonaws.s3.synthetic",
  806    806   
        "CopyObjectInput",
  807    807   
    ),
  808    808   
    ::aws_smithy_schema::ShapeType::String,
  809         -
    "bucket",
         809  +
    "Bucket",
  810    810   
    1,
  811    811   
)
  812    812   
.with_http_label();
  813    813   
static COPYOBJECTINPUT_MEMBER_CACHE_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  814    814   
    ::aws_smithy_schema::ShapeId::from_static(
  815    815   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CacheControl",
  816    816   
        "com.amazonaws.s3.synthetic",
  817    817   
        "CopyObjectInput",
  818    818   
    ),
  819    819   
    ::aws_smithy_schema::ShapeType::String,
  820         -
    "cache_control",
         820  +
    "CacheControl",
  821    821   
    2,
  822    822   
)
  823    823   
.with_http_header("Cache-Control");
  824    824   
static COPYOBJECTINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  825    825   
    ::aws_smithy_schema::ShapeId::from_static(
  826    826   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ChecksumAlgorithm",
  827    827   
        "com.amazonaws.s3.synthetic",
  828    828   
        "CopyObjectInput",
  829    829   
    ),
  830    830   
    ::aws_smithy_schema::ShapeType::String,
  831         -
    "checksum_algorithm",
         831  +
    "ChecksumAlgorithm",
  832    832   
    3,
  833    833   
)
  834    834   
.with_http_header("x-amz-checksum-algorithm");
  835    835   
static COPYOBJECTINPUT_MEMBER_CONTENT_DISPOSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  836    836   
    ::aws_smithy_schema::ShapeId::from_static(
  837    837   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ContentDisposition",
  838    838   
        "com.amazonaws.s3.synthetic",
  839    839   
        "CopyObjectInput",
  840    840   
    ),
  841    841   
    ::aws_smithy_schema::ShapeType::String,
  842         -
    "content_disposition",
         842  +
    "ContentDisposition",
  843    843   
    4,
  844    844   
)
  845    845   
.with_http_header("Content-Disposition");
  846    846   
static COPYOBJECTINPUT_MEMBER_CONTENT_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  847    847   
    ::aws_smithy_schema::ShapeId::from_static(
  848    848   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ContentEncoding",
  849    849   
        "com.amazonaws.s3.synthetic",
  850    850   
        "CopyObjectInput",
  851    851   
    ),
  852    852   
    ::aws_smithy_schema::ShapeType::String,
  853         -
    "content_encoding",
         853  +
    "ContentEncoding",
  854    854   
    5,
  855    855   
)
  856    856   
.with_http_header("Content-Encoding");
  857    857   
static COPYOBJECTINPUT_MEMBER_CONTENT_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  858    858   
    ::aws_smithy_schema::ShapeId::from_static(
  859    859   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ContentLanguage",
  860    860   
        "com.amazonaws.s3.synthetic",
  861    861   
        "CopyObjectInput",
  862    862   
    ),
  863    863   
    ::aws_smithy_schema::ShapeType::String,
  864         -
    "content_language",
         864  +
    "ContentLanguage",
  865    865   
    6,
  866    866   
)
  867    867   
.with_http_header("Content-Language");
  868    868   
static COPYOBJECTINPUT_MEMBER_CONTENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  869    869   
    ::aws_smithy_schema::ShapeId::from_static(
  870    870   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ContentType",
  871    871   
        "com.amazonaws.s3.synthetic",
  872    872   
        "CopyObjectInput",
  873    873   
    ),
  874    874   
    ::aws_smithy_schema::ShapeType::String,
  875         -
    "content_type",
         875  +
    "ContentType",
  876    876   
    7,
  877    877   
)
  878    878   
.with_http_header("Content-Type");
  879    879   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  880    880   
    ::aws_smithy_schema::ShapeId::from_static(
  881    881   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySource",
  882    882   
        "com.amazonaws.s3.synthetic",
  883    883   
        "CopyObjectInput",
  884    884   
    ),
  885    885   
    ::aws_smithy_schema::ShapeType::String,
  886         -
    "copy_source",
         886  +
    "CopySource",
  887    887   
    8,
  888    888   
)
  889    889   
.with_http_header("x-amz-copy-source");
  890    890   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  891    891   
    ::aws_smithy_schema::ShapeId::from_static(
  892    892   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceIfMatch",
  893    893   
        "com.amazonaws.s3.synthetic",
  894    894   
        "CopyObjectInput",
  895    895   
    ),
  896    896   
    ::aws_smithy_schema::ShapeType::String,
  897         -
    "copy_source_if_match",
         897  +
    "CopySourceIfMatch",
  898    898   
    9,
  899    899   
)
  900    900   
.with_http_header("x-amz-copy-source-if-match");
  901    901   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_MODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  902    902   
    ::aws_smithy_schema::ShapeId::from_static(
  903    903   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceIfModifiedSince",
  904    904   
        "com.amazonaws.s3.synthetic",
  905    905   
        "CopyObjectInput",
  906    906   
    ),
  907    907   
    ::aws_smithy_schema::ShapeType::Timestamp,
  908         -
    "copy_source_if_modified_since",
         908  +
    "CopySourceIfModifiedSince",
  909    909   
    10,
  910    910   
)
  911    911   
.with_http_header("x-amz-copy-source-if-modified-since");
  912    912   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  913    913   
    ::aws_smithy_schema::ShapeId::from_static(
  914    914   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceIfNoneMatch",
  915    915   
        "com.amazonaws.s3.synthetic",
  916    916   
        "CopyObjectInput",
  917    917   
    ),
  918    918   
    ::aws_smithy_schema::ShapeType::String,
  919         -
    "copy_source_if_none_match",
         919  +
    "CopySourceIfNoneMatch",
  920    920   
    11,
  921    921   
)
  922    922   
.with_http_header("x-amz-copy-source-if-none-match");
  923    923   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_UNMODIFIED_SINCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  924    924   
    ::aws_smithy_schema::ShapeId::from_static(
  925    925   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceIfUnmodifiedSince",
  926    926   
        "com.amazonaws.s3.synthetic",
  927    927   
        "CopyObjectInput",
  928    928   
    ),
  929    929   
    ::aws_smithy_schema::ShapeType::Timestamp,
  930         -
    "copy_source_if_unmodified_since",
         930  +
    "CopySourceIfUnmodifiedSince",
  931    931   
    12,
  932    932   
)
  933    933   
.with_http_header("x-amz-copy-source-if-unmodified-since");
  934    934   
static COPYOBJECTINPUT_MEMBER_EXPIRES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  935    935   
    ::aws_smithy_schema::ShapeId::from_static(
  936    936   
        "com.amazonaws.s3.synthetic#CopyObjectInput$Expires",
  937    937   
        "com.amazonaws.s3.synthetic",
  938    938   
        "CopyObjectInput",
  939    939   
    ),
  940    940   
    ::aws_smithy_schema::ShapeType::Timestamp,
  941         -
    "expires",
         941  +
    "Expires",
  942    942   
    13,
  943    943   
)
  944    944   
.with_http_header("Expires");
  945    945   
static COPYOBJECTINPUT_MEMBER_GRANT_FULL_CONTROL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  946    946   
    ::aws_smithy_schema::ShapeId::from_static(
  947    947   
        "com.amazonaws.s3.synthetic#CopyObjectInput$GrantFullControl",
  948    948   
        "com.amazonaws.s3.synthetic",
  949    949   
        "CopyObjectInput",
  950    950   
    ),
  951    951   
    ::aws_smithy_schema::ShapeType::String,
  952         -
    "grant_full_control",
         952  +
    "GrantFullControl",
  953    953   
    14,
  954    954   
)
  955    955   
.with_http_header("x-amz-grant-full-control");
  956    956   
static COPYOBJECTINPUT_MEMBER_GRANT_READ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  957    957   
    ::aws_smithy_schema::ShapeId::from_static(
  958    958   
        "com.amazonaws.s3.synthetic#CopyObjectInput$GrantRead",
  959    959   
        "com.amazonaws.s3.synthetic",
  960    960   
        "CopyObjectInput",
  961    961   
    ),
  962    962   
    ::aws_smithy_schema::ShapeType::String,
  963         -
    "grant_read",
         963  +
    "GrantRead",
  964    964   
    15,
  965    965   
)
  966    966   
.with_http_header("x-amz-grant-read");
  967    967   
static COPYOBJECTINPUT_MEMBER_GRANT_READ_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  968    968   
    ::aws_smithy_schema::ShapeId::from_static(
  969    969   
        "com.amazonaws.s3.synthetic#CopyObjectInput$GrantReadACP",
  970    970   
        "com.amazonaws.s3.synthetic",
  971    971   
        "CopyObjectInput",
  972    972   
    ),
  973    973   
    ::aws_smithy_schema::ShapeType::String,
  974         -
    "grant_read_acp",
         974  +
    "GrantReadACP",
  975    975   
    16,
  976    976   
)
  977    977   
.with_http_header("x-amz-grant-read-acp");
  978    978   
static COPYOBJECTINPUT_MEMBER_GRANT_WRITE_ACP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  979    979   
    ::aws_smithy_schema::ShapeId::from_static(
  980    980   
        "com.amazonaws.s3.synthetic#CopyObjectInput$GrantWriteACP",
  981    981   
        "com.amazonaws.s3.synthetic",
  982    982   
        "CopyObjectInput",
  983    983   
    ),
  984    984   
    ::aws_smithy_schema::ShapeType::String,
  985         -
    "grant_write_acp",
         985  +
    "GrantWriteACP",
  986    986   
    17,
  987    987   
)
  988    988   
.with_http_header("x-amz-grant-write-acp");
  989    989   
static COPYOBJECTINPUT_MEMBER_IF_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  990    990   
    ::aws_smithy_schema::ShapeId::from_static(
  991    991   
        "com.amazonaws.s3.synthetic#CopyObjectInput$IfMatch",
  992    992   
        "com.amazonaws.s3.synthetic",
  993    993   
        "CopyObjectInput",
  994    994   
    ),
  995    995   
    ::aws_smithy_schema::ShapeType::String,
  996         -
    "if_match",
         996  +
    "IfMatch",
  997    997   
    18,
  998    998   
)
  999    999   
.with_http_header("If-Match");
 1000   1000   
static COPYOBJECTINPUT_MEMBER_IF_NONE_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1001   1001   
    ::aws_smithy_schema::ShapeId::from_static(
 1002   1002   
        "com.amazonaws.s3.synthetic#CopyObjectInput$IfNoneMatch",
 1003   1003   
        "com.amazonaws.s3.synthetic",
 1004   1004   
        "CopyObjectInput",
 1005   1005   
    ),
 1006   1006   
    ::aws_smithy_schema::ShapeType::String,
 1007         -
    "if_none_match",
        1007  +
    "IfNoneMatch",
 1008   1008   
    19,
 1009   1009   
)
 1010   1010   
.with_http_header("If-None-Match");
 1011   1011   
static COPYOBJECTINPUT_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1012   1012   
    ::aws_smithy_schema::ShapeId::from_static(
 1013   1013   
        "com.amazonaws.s3.synthetic#CopyObjectInput$Key",
 1014   1014   
        "com.amazonaws.s3.synthetic",
 1015   1015   
        "CopyObjectInput",
 1016   1016   
    ),
 1017   1017   
    ::aws_smithy_schema::ShapeType::String,
 1018         -
    "key",
        1018  +
    "Key",
 1019   1019   
    20,
 1020   1020   
)
 1021   1021   
.with_http_label();
 1022   1022   
static COPYOBJECTINPUT_MEMBER_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1023   1023   
    ::aws_smithy_schema::ShapeId::from_static(
 1024   1024   
        "com.amazonaws.s3.synthetic#CopyObjectInput$Metadata",
 1025   1025   
        "com.amazonaws.s3.synthetic",
 1026   1026   
        "CopyObjectInput",
 1027   1027   
    ),
 1028   1028   
    ::aws_smithy_schema::ShapeType::Map,
 1029         -
    "metadata",
        1029  +
    "Metadata",
 1030   1030   
    21,
 1031   1031   
)
 1032   1032   
.with_http_prefix_headers("x-amz-meta-");
 1033   1033   
static COPYOBJECTINPUT_MEMBER_METADATA_DIRECTIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1034   1034   
    ::aws_smithy_schema::ShapeId::from_static(
 1035   1035   
        "com.amazonaws.s3.synthetic#CopyObjectInput$MetadataDirective",
 1036   1036   
        "com.amazonaws.s3.synthetic",
 1037   1037   
        "CopyObjectInput",
 1038   1038   
    ),
 1039   1039   
    ::aws_smithy_schema::ShapeType::String,
 1040         -
    "metadata_directive",
        1040  +
    "MetadataDirective",
 1041   1041   
    22,
 1042   1042   
)
 1043   1043   
.with_http_header("x-amz-metadata-directive");
 1044   1044   
static COPYOBJECTINPUT_MEMBER_TAGGING_DIRECTIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1045   1045   
    ::aws_smithy_schema::ShapeId::from_static(
 1046   1046   
        "com.amazonaws.s3.synthetic#CopyObjectInput$TaggingDirective",
 1047   1047   
        "com.amazonaws.s3.synthetic",
 1048   1048   
        "CopyObjectInput",
 1049   1049   
    ),
 1050   1050   
    ::aws_smithy_schema::ShapeType::String,
 1051         -
    "tagging_directive",
        1051  +
    "TaggingDirective",
 1052   1052   
    23,
 1053   1053   
)
 1054   1054   
.with_http_header("x-amz-tagging-directive");
 1055   1055   
static COPYOBJECTINPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1056   1056   
    ::aws_smithy_schema::ShapeId::from_static(
 1057   1057   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ServerSideEncryption",
 1058   1058   
        "com.amazonaws.s3.synthetic",
 1059   1059   
        "CopyObjectInput",
 1060   1060   
    ),
 1061   1061   
    ::aws_smithy_schema::ShapeType::String,
 1062         -
    "server_side_encryption",
        1062  +
    "ServerSideEncryption",
 1063   1063   
    24,
 1064   1064   
)
 1065   1065   
.with_http_header("x-amz-server-side-encryption");
 1066   1066   
static COPYOBJECTINPUT_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1067   1067   
    ::aws_smithy_schema::ShapeId::from_static(
 1068   1068   
        "com.amazonaws.s3.synthetic#CopyObjectInput$StorageClass",
 1069   1069   
        "com.amazonaws.s3.synthetic",
 1070   1070   
        "CopyObjectInput",
 1071   1071   
    ),
 1072   1072   
    ::aws_smithy_schema::ShapeType::String,
 1073         -
    "storage_class",
        1073  +
    "StorageClass",
 1074   1074   
    25,
 1075   1075   
)
 1076   1076   
.with_http_header("x-amz-storage-class");
 1077   1077   
static COPYOBJECTINPUT_MEMBER_WEBSITE_REDIRECT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1078   1078   
    ::aws_smithy_schema::ShapeId::from_static(
 1079   1079   
        "com.amazonaws.s3.synthetic#CopyObjectInput$WebsiteRedirectLocation",
 1080   1080   
        "com.amazonaws.s3.synthetic",
 1081   1081   
        "CopyObjectInput",
 1082   1082   
    ),
 1083   1083   
    ::aws_smithy_schema::ShapeType::String,
 1084         -
    "website_redirect_location",
        1084  +
    "WebsiteRedirectLocation",
 1085   1085   
    26,
 1086   1086   
)
 1087   1087   
.with_http_header("x-amz-website-redirect-location");
 1088   1088   
static COPYOBJECTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1089   1089   
    ::aws_smithy_schema::ShapeId::from_static(
 1090   1090   
        "com.amazonaws.s3.synthetic#CopyObjectInput$SSECustomerAlgorithm",
 1091   1091   
        "com.amazonaws.s3.synthetic",
 1092   1092   
        "CopyObjectInput",
 1093   1093   
    ),
 1094   1094   
    ::aws_smithy_schema::ShapeType::String,
 1095         -
    "sse_customer_algorithm",
        1095  +
    "SSECustomerAlgorithm",
 1096   1096   
    27,
 1097   1097   
)
 1098   1098   
.with_http_header("x-amz-server-side-encryption-customer-algorithm");
 1099   1099   
static COPYOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1100   1100   
    ::aws_smithy_schema::ShapeId::from_static(
 1101   1101   
        "com.amazonaws.s3.synthetic#CopyObjectInput$SSECustomerKey",
 1102   1102   
        "com.amazonaws.s3.synthetic",
 1103   1103   
        "CopyObjectInput",
 1104   1104   
    ),
 1105   1105   
    ::aws_smithy_schema::ShapeType::String,
 1106         -
    "sse_customer_key",
        1106  +
    "SSECustomerKey",
 1107   1107   
    28,
 1108   1108   
)
 1109   1109   
.with_http_header("x-amz-server-side-encryption-customer-key");
 1110   1110   
static COPYOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1111   1111   
    ::aws_smithy_schema::ShapeId::from_static(
 1112   1112   
        "com.amazonaws.s3.synthetic#CopyObjectInput$SSECustomerKeyMD5",
 1113   1113   
        "com.amazonaws.s3.synthetic",
 1114   1114   
        "CopyObjectInput",
 1115   1115   
    ),
 1116   1116   
    ::aws_smithy_schema::ShapeType::String,
 1117         -
    "sse_customer_key_md5",
        1117  +
    "SSECustomerKeyMD5",
 1118   1118   
    29,
 1119   1119   
)
 1120   1120   
.with_http_header("x-amz-server-side-encryption-customer-key-MD5");
 1121   1121   
static COPYOBJECTINPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1122   1122   
    ::aws_smithy_schema::ShapeId::from_static(
 1123   1123   
        "com.amazonaws.s3.synthetic#CopyObjectInput$SSEKMSKeyId",
 1124   1124   
        "com.amazonaws.s3.synthetic",
 1125   1125   
        "CopyObjectInput",
 1126   1126   
    ),
 1127   1127   
    ::aws_smithy_schema::ShapeType::String,
 1128         -
    "ssekms_key_id",
        1128  +
    "SSEKMSKeyId",
 1129   1129   
    30,
 1130   1130   
)
 1131   1131   
.with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
 1132   1132   
static COPYOBJECTINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1133   1133   
    ::aws_smithy_schema::ShapeId::from_static(
 1134   1134   
        "com.amazonaws.s3.synthetic#CopyObjectInput$SSEKMSEncryptionContext",
 1135   1135   
        "com.amazonaws.s3.synthetic",
 1136   1136   
        "CopyObjectInput",
 1137   1137   
    ),
 1138   1138   
    ::aws_smithy_schema::ShapeType::String,
 1139         -
    "ssekms_encryption_context",
        1139  +
    "SSEKMSEncryptionContext",
 1140   1140   
    31,
 1141   1141   
)
 1142   1142   
.with_http_header("x-amz-server-side-encryption-context");
 1143   1143   
static COPYOBJECTINPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1144   1144   
    ::aws_smithy_schema::ShapeId::from_static(
 1145   1145   
        "com.amazonaws.s3.synthetic#CopyObjectInput$BucketKeyEnabled",
 1146   1146   
        "com.amazonaws.s3.synthetic",
 1147   1147   
        "CopyObjectInput",
 1148   1148   
    ),
 1149   1149   
    ::aws_smithy_schema::ShapeType::Boolean,
 1150         -
    "bucket_key_enabled",
        1150  +
    "BucketKeyEnabled",
 1151   1151   
    32,
 1152   1152   
)
 1153   1153   
.with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
 1154   1154   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1155   1155   
    ::aws_smithy_schema::ShapeId::from_static(
 1156   1156   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceSSECustomerAlgorithm",
 1157   1157   
        "com.amazonaws.s3.synthetic",
 1158   1158   
        "CopyObjectInput",
 1159   1159   
    ),
 1160   1160   
    ::aws_smithy_schema::ShapeType::String,
 1161         -
    "copy_source_sse_customer_algorithm",
        1161  +
    "CopySourceSSECustomerAlgorithm",
 1162   1162   
    33,
 1163   1163   
)
 1164   1164   
.with_http_header("x-amz-copy-source-server-side-encryption-customer-algorithm");
 1165   1165   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1166   1166   
    ::aws_smithy_schema::ShapeId::from_static(
 1167   1167   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceSSECustomerKey",
 1168   1168   
        "com.amazonaws.s3.synthetic",
 1169   1169   
        "CopyObjectInput",
 1170   1170   
    ),
 1171   1171   
    ::aws_smithy_schema::ShapeType::String,
 1172         -
    "copy_source_sse_customer_key",
        1172  +
    "CopySourceSSECustomerKey",
 1173   1173   
    34,
 1174   1174   
)
 1175   1175   
.with_http_header("x-amz-copy-source-server-side-encryption-customer-key");
 1176   1176   
static COPYOBJECTINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1177   1177   
    ::aws_smithy_schema::ShapeId::from_static(
 1178   1178   
        "com.amazonaws.s3.synthetic#CopyObjectInput$CopySourceSSECustomerKeyMD5",
 1179   1179   
        "com.amazonaws.s3.synthetic",
 1180   1180   
        "CopyObjectInput",
 1181   1181   
    ),
 1182   1182   
    ::aws_smithy_schema::ShapeType::String,
 1183         -
    "copy_source_sse_customer_key_md5",
        1183  +
    "CopySourceSSECustomerKeyMD5",
 1184   1184   
    35,
 1185   1185   
)
 1186   1186   
.with_http_header("x-amz-copy-source-server-side-encryption-customer-key-MD5");
 1187   1187   
static COPYOBJECTINPUT_MEMBER_REQUEST_PAYER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1188   1188   
    ::aws_smithy_schema::ShapeId::from_static(
 1189   1189   
        "com.amazonaws.s3.synthetic#CopyObjectInput$RequestPayer",
 1190   1190   
        "com.amazonaws.s3.synthetic",
 1191   1191   
        "CopyObjectInput",
 1192   1192   
    ),
 1193   1193   
    ::aws_smithy_schema::ShapeType::String,
 1194         -
    "request_payer",
        1194  +
    "RequestPayer",
 1195   1195   
    36,
 1196   1196   
)
 1197   1197   
.with_http_header("x-amz-request-payer");
 1198   1198   
static COPYOBJECTINPUT_MEMBER_TAGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1199   1199   
    ::aws_smithy_schema::ShapeId::from_static(
 1200   1200   
        "com.amazonaws.s3.synthetic#CopyObjectInput$Tagging",
 1201   1201   
        "com.amazonaws.s3.synthetic",
 1202   1202   
        "CopyObjectInput",
 1203   1203   
    ),
 1204   1204   
    ::aws_smithy_schema::ShapeType::String,
 1205         -
    "tagging",
        1205  +
    "Tagging",
 1206   1206   
    37,
 1207   1207   
)
 1208   1208   
.with_http_header("x-amz-tagging");
 1209   1209   
static COPYOBJECTINPUT_MEMBER_OBJECT_LOCK_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1210   1210   
    ::aws_smithy_schema::ShapeId::from_static(
 1211   1211   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ObjectLockMode",
 1212   1212   
        "com.amazonaws.s3.synthetic",
 1213   1213   
        "CopyObjectInput",
 1214   1214   
    ),
 1215   1215   
    ::aws_smithy_schema::ShapeType::String,
 1216         -
    "object_lock_mode",
        1216  +
    "ObjectLockMode",
 1217   1217   
    38,
 1218   1218   
)
 1219   1219   
.with_http_header("x-amz-object-lock-mode");
 1220   1220   
static COPYOBJECTINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1221   1221   
    ::aws_smithy_schema::ShapeId::from_static(
 1222   1222   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ObjectLockRetainUntilDate",
 1223   1223   
        "com.amazonaws.s3.synthetic",
 1224   1224   
        "CopyObjectInput",
 1225   1225   
    ),
 1226   1226   
    ::aws_smithy_schema::ShapeType::Timestamp,
 1227         -
    "object_lock_retain_until_date",
        1227  +
    "ObjectLockRetainUntilDate",
 1228   1228   
    39,
 1229   1229   
)
 1230         -
.with_http_header("x-amz-object-lock-retain-until-date");
        1230  +
.with_http_header("x-amz-object-lock-retain-until-date")
        1231  +
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
 1231   1232   
static COPYOBJECTINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1232   1233   
    ::aws_smithy_schema::ShapeId::from_static(
 1233   1234   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ObjectLockLegalHoldStatus",
 1234   1235   
        "com.amazonaws.s3.synthetic",
 1235   1236   
        "CopyObjectInput",
 1236   1237   
    ),
 1237   1238   
    ::aws_smithy_schema::ShapeType::String,
 1238         -
    "object_lock_legal_hold_status",
        1239  +
    "ObjectLockLegalHoldStatus",
 1239   1240   
    40,
 1240   1241   
)
 1241   1242   
.with_http_header("x-amz-object-lock-legal-hold");
 1242   1243   
static COPYOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1243   1244   
    ::aws_smithy_schema::ShapeId::from_static(
 1244   1245   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ExpectedBucketOwner",
 1245   1246   
        "com.amazonaws.s3.synthetic",
 1246   1247   
        "CopyObjectInput",
 1247   1248   
    ),
 1248   1249   
    ::aws_smithy_schema::ShapeType::String,
 1249         -
    "expected_bucket_owner",
        1250  +
    "ExpectedBucketOwner",
 1250   1251   
    41,
 1251   1252   
)
 1252   1253   
.with_http_header("x-amz-expected-bucket-owner");
 1253   1254   
static COPYOBJECTINPUT_MEMBER_EXPECTED_SOURCE_BUCKET_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1254   1255   
    ::aws_smithy_schema::ShapeId::from_static(
 1255   1256   
        "com.amazonaws.s3.synthetic#CopyObjectInput$ExpectedSourceBucketOwner",
 1256   1257   
        "com.amazonaws.s3.synthetic",
 1257   1258   
        "CopyObjectInput",
 1258   1259   
    ),
 1259   1260   
    ::aws_smithy_schema::ShapeType::String,
 1260         -
    "expected_source_bucket_owner",
        1261  +
    "ExpectedSourceBucketOwner",
 1261   1262   
    42,
 1262   1263   
)
 1263   1264   
.with_http_header("x-amz-source-expected-bucket-owner");
 1264   1265   
static COPYOBJECTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
 1265   1266   
    COPYOBJECTINPUT_SCHEMA_ID,
 1266   1267   
    ::aws_smithy_schema::ShapeType::Structure,
 1267   1268   
    &[
 1268   1269   
        &COPYOBJECTINPUT_MEMBER_ACL,
 1269   1270   
        &COPYOBJECTINPUT_MEMBER_BUCKET,
 1270   1271   
        &COPYOBJECTINPUT_MEMBER_CACHE_CONTROL,
 1271   1272   
        &COPYOBJECTINPUT_MEMBER_CHECKSUM_ALGORITHM,
 1272   1273   
        &COPYOBJECTINPUT_MEMBER_CONTENT_DISPOSITION,
 1273   1274   
        &COPYOBJECTINPUT_MEMBER_CONTENT_ENCODING,
 1274   1275   
        &COPYOBJECTINPUT_MEMBER_CONTENT_LANGUAGE,
 1275   1276   
        &COPYOBJECTINPUT_MEMBER_CONTENT_TYPE,
 1276   1277   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE,
 1277   1278   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_MATCH,
 1278   1279   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_MODIFIED_SINCE,
 1279   1280   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_NONE_MATCH,
 1280   1281   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_IF_UNMODIFIED_SINCE,
 1281   1282   
        &COPYOBJECTINPUT_MEMBER_EXPIRES,
 1282   1283   
        &COPYOBJECTINPUT_MEMBER_GRANT_FULL_CONTROL,
 1283   1284   
        &COPYOBJECTINPUT_MEMBER_GRANT_READ,
 1284   1285   
        &COPYOBJECTINPUT_MEMBER_GRANT_READ_ACP,
 1285   1286   
        &COPYOBJECTINPUT_MEMBER_GRANT_WRITE_ACP,
 1286   1287   
        &COPYOBJECTINPUT_MEMBER_IF_MATCH,
 1287   1288   
        &COPYOBJECTINPUT_MEMBER_IF_NONE_MATCH,
 1288   1289   
        &COPYOBJECTINPUT_MEMBER_KEY,
 1289   1290   
        &COPYOBJECTINPUT_MEMBER_METADATA,
 1290   1291   
        &COPYOBJECTINPUT_MEMBER_METADATA_DIRECTIVE,
 1291   1292   
        &COPYOBJECTINPUT_MEMBER_TAGGING_DIRECTIVE,
 1292   1293   
        &COPYOBJECTINPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
 1293   1294   
        &COPYOBJECTINPUT_MEMBER_STORAGE_CLASS,
 1294   1295   
        &COPYOBJECTINPUT_MEMBER_WEBSITE_REDIRECT_LOCATION,
 1295   1296   
        &COPYOBJECTINPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
 1296   1297   
        &COPYOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY,
 1297   1298   
        &COPYOBJECTINPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
 1298   1299   
        &COPYOBJECTINPUT_MEMBER_SSEKMS_KEY_ID,
 1299   1300   
        &COPYOBJECTINPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
 1300   1301   
        &COPYOBJECTINPUT_MEMBER_BUCKET_KEY_ENABLED,
 1301   1302   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_ALGORITHM,
 1302   1303   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY,
 1303   1304   
        &COPYOBJECTINPUT_MEMBER_COPY_SOURCE_SSE_CUSTOMER_KEY_MD5,
 1304   1305   
        &COPYOBJECTINPUT_MEMBER_REQUEST_PAYER,
 1305   1306   
        &COPYOBJECTINPUT_MEMBER_TAGGING,
 1306   1307   
        &COPYOBJECTINPUT_MEMBER_OBJECT_LOCK_MODE,
 1307   1308   
        &COPYOBJECTINPUT_MEMBER_OBJECT_LOCK_RETAIN_UNTIL_DATE,
 1308   1309   
        &COPYOBJECTINPUT_MEMBER_OBJECT_LOCK_LEGAL_HOLD_STATUS,
 1309   1310   
        &COPYOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER,
 1310   1311   
        &COPYOBJECTINPUT_MEMBER_EXPECTED_SOURCE_BUCKET_OWNER,
 1311   1312   
    ],
 1312         -
);
        1313  +
)
        1314  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/{Key+}?x-id=CopyObject", None));
 1313   1315   
impl CopyObjectInput {
 1314   1316   
    /// The schema for this shape.
 1315   1317   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYOBJECTINPUT_SCHEMA;
 1316   1318   
}
 1317   1319   
impl ::aws_smithy_schema::serde::SerializableStruct for CopyObjectInput {
 1318   1320   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
 1319   1321   
    fn serialize_members(
 1320   1322   
        &self,
 1321   1323   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
 1322   1324   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -1436,1438 +1508,1510 @@
 1456   1458   
            ser.write_string(&COPYOBJECTINPUT_MEMBER_EXPECTED_BUCKET_OWNER, val)?;
 1457   1459   
        }
 1458   1460   
        if let Some(ref val) = self.expected_source_bucket_owner {
 1459   1461   
            ser.write_string(&COPYOBJECTINPUT_MEMBER_EXPECTED_SOURCE_BUCKET_OWNER, val)?;
 1460   1462   
        }
 1461   1463   
        Ok(())
 1462   1464   
    }
 1463   1465   
}
 1464   1466   
impl CopyObjectInput {
 1465   1467   
    /// Deserializes this structure from a [`ShapeDeserializer`].
 1466         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
 1467         -
        deserializer: &mut D,
        1468  +
    pub fn deserialize(
        1469  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
 1468   1470   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
 1469   1471   
        #[allow(unused_variables, unused_mut)]
 1470   1472   
        let mut builder = Self::builder();
 1471   1473   
        #[allow(
 1472   1474   
            unused_variables,
 1473   1475   
            unreachable_code,
 1474   1476   
            clippy::single_match,
 1475   1477   
            clippy::match_single_binding,
 1476   1478   
            clippy::diverging_sub_expression
 1477   1479   
        )]
 1478         -
        deserializer.read_struct(&COPYOBJECTINPUT_SCHEMA, (), |_, member, deser| {
        1480  +
        deserializer.read_struct(&COPYOBJECTINPUT_SCHEMA, &mut |member, deser| {
 1479   1481   
            match member.member_index() {
 1480   1482   
                Some(0) => {
 1481   1483   
                    builder.acl = Some(crate::types::ObjectCannedAcl::from(deser.read_string(member)?.as_str()));
 1482   1484   
                }
 1483   1485   
                Some(1) => {
 1484   1486   
                    builder.bucket = Some(deser.read_string(member)?);
 1485   1487   
                }
 1486   1488   
                Some(2) => {
 1487   1489   
                    builder.cache_control = Some(deser.read_string(member)?);
 1488   1490   
                }
@@ -1514,1516 +1584,1576 @@
 1534   1536   
                Some(18) => {
 1535   1537   
                    builder.if_match = Some(deser.read_string(member)?);
 1536   1538   
                }
 1537   1539   
                Some(19) => {
 1538   1540   
                    builder.if_none_match = Some(deser.read_string(member)?);
 1539   1541   
                }
 1540   1542   
                Some(20) => {
 1541   1543   
                    builder.key = Some(deser.read_string(member)?);
 1542   1544   
                }
 1543   1545   
                Some(21) => {
 1544         -
                    builder.metadata = Some({
 1545         -
                        let container = if let Some(cap) = deser.container_size() {
 1546         -
                            std::collections::HashMap::with_capacity(cap)
 1547         -
                        } else {
 1548         -
                            std::collections::HashMap::new()
 1549         -
                        };
 1550         -
                        deser.read_map(member, container, |mut map, key, deser| {
 1551         -
                            map.insert(key, deser.read_string(member)?);
 1552         -
                            Ok(map)
 1553         -
                        })?
 1554         -
                    });
        1546  +
                    builder.metadata = Some(deser.read_string_string_map(member)?);
 1555   1547   
                }
 1556   1548   
                Some(22) => {
 1557   1549   
                    builder.metadata_directive = Some(crate::types::MetadataDirective::from(deser.read_string(member)?.as_str()));
 1558   1550   
                }
 1559   1551   
                Some(23) => {
 1560   1552   
                    builder.tagging_directive = Some(crate::types::TaggingDirective::from(deser.read_string(member)?.as_str()));
 1561   1553   
                }
 1562   1554   
                Some(24) => {
 1563   1555   
                    builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
 1564   1556   
                }
@@ -1593,1585 +1652,1856 @@
 1613   1605   
                Some(41) => {
 1614   1606   
                    builder.expected_bucket_owner = Some(deser.read_string(member)?);
 1615   1607   
                }
 1616   1608   
                Some(42) => {
 1617   1609   
                    builder.expected_source_bucket_owner = Some(deser.read_string(member)?);
 1618   1610   
                }
 1619   1611   
                _ => {}
 1620   1612   
            }
 1621   1613   
            Ok(())
 1622   1614   
        })?;
        1615  +
        builder.bucket = builder.bucket.or(Some(String::new()));
        1616  +
        builder.copy_source = builder.copy_source.or(Some(String::new()));
        1617  +
        builder.key = builder.key.or(Some(String::new()));
        1618  +
        builder
        1619  +
            .build()
        1620  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
        1621  +
    }
        1622  +
}
        1623  +
impl CopyObjectInput {
        1624  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
        1625  +
    /// Header-bound members are read directly from headers, avoiding runtime
        1626  +
    /// member iteration overhead. Body members are read via the deserializer.
        1627  +
    pub fn deserialize_with_response(
        1628  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1629  +
        headers: &::aws_smithy_runtime_api::http::Headers,
        1630  +
        _status: u16,
        1631  +
        _body: &[u8],
        1632  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1633  +
        #[allow(unused_variables, unused_mut)]
        1634  +
        let mut builder = Self::builder();
        1635  +
        if let Some(val) = headers.get("x-amz-acl") {
        1636  +
            builder.acl = Some(crate::types::ObjectCannedAcl::from(val));
        1637  +
        }
        1638  +
        if let Some(val) = headers.get("Cache-Control") {
        1639  +
            builder.cache_control = Some(val.to_string());
        1640  +
        }
        1641  +
        if let Some(val) = headers.get("x-amz-checksum-algorithm") {
        1642  +
            builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
        1643  +
        }
        1644  +
        if let Some(val) = headers.get("Content-Disposition") {
        1645  +
            builder.content_disposition = Some(val.to_string());
        1646  +
        }
        1647  +
        if let Some(val) = headers.get("Content-Encoding") {
        1648  +
            builder.content_encoding = Some(val.to_string());
        1649  +
        }
        1650  +
        if let Some(val) = headers.get("Content-Language") {
        1651  +
            builder.content_language = Some(val.to_string());
        1652  +
        }
        1653  +
        if let Some(val) = headers.get("Content-Type") {
        1654  +
            builder.content_type = Some(val.to_string());
        1655  +
        }
        1656  +
        if let Some(val) = headers.get("x-amz-copy-source") {
        1657  +
            builder.copy_source = Some(val.to_string());
        1658  +
        }
        1659  +
        if let Some(val) = headers.get("x-amz-copy-source-if-match") {
        1660  +
            builder.copy_source_if_match = Some(val.to_string());
        1661  +
        }
        1662  +
        if let Some(val) = headers.get("x-amz-copy-source-if-modified-since") {
        1663  +
            builder.copy_source_if_modified_since = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
        1664  +
        }
        1665  +
        if let Some(val) = headers.get("x-amz-copy-source-if-none-match") {
        1666  +
            builder.copy_source_if_none_match = Some(val.to_string());
        1667  +
        }
        1668  +
        if let Some(val) = headers.get("x-amz-copy-source-if-unmodified-since") {
        1669  +
            builder.copy_source_if_unmodified_since =
        1670  +
                ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
        1671  +
        }
        1672  +
        if let Some(val) = headers.get("Expires") {
        1673  +
            builder.expires = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::HttpDate).ok();
        1674  +
        }
        1675  +
        if let Some(val) = headers.get("x-amz-grant-full-control") {
        1676  +
            builder.grant_full_control = Some(val.to_string());
        1677  +
        }
        1678  +
        if let Some(val) = headers.get("x-amz-grant-read") {
        1679  +
            builder.grant_read = Some(val.to_string());
        1680  +
        }
        1681  +
        if let Some(val) = headers.get("x-amz-grant-read-acp") {
        1682  +
            builder.grant_read_acp = Some(val.to_string());
        1683  +
        }
        1684  +
        if let Some(val) = headers.get("x-amz-grant-write-acp") {
        1685  +
            builder.grant_write_acp = Some(val.to_string());
        1686  +
        }
        1687  +
        if let Some(val) = headers.get("If-Match") {
        1688  +
            builder.if_match = Some(val.to_string());
        1689  +
        }
        1690  +
        if let Some(val) = headers.get("If-None-Match") {
        1691  +
            builder.if_none_match = Some(val.to_string());
        1692  +
        }
        1693  +
        if let Some(val) = headers.get("x-amz-metadata-directive") {
        1694  +
            builder.metadata_directive = Some(crate::types::MetadataDirective::from(val));
        1695  +
        }
        1696  +
        if let Some(val) = headers.get("x-amz-tagging-directive") {
        1697  +
            builder.tagging_directive = Some(crate::types::TaggingDirective::from(val));
        1698  +
        }
        1699  +
        if let Some(val) = headers.get("x-amz-server-side-encryption") {
        1700  +
            builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
        1701  +
        }
        1702  +
        if let Some(val) = headers.get("x-amz-storage-class") {
        1703  +
            builder.storage_class = Some(crate::types::StorageClass::from(val));
        1704  +
        }
        1705  +
        if let Some(val) = headers.get("x-amz-website-redirect-location") {
        1706  +
            builder.website_redirect_location = Some(val.to_string());
        1707  +
        }
        1708  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
        1709  +
            builder.sse_customer_algorithm = Some(val.to_string());
        1710  +
        }
        1711  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key") {
        1712  +
            builder.sse_customer_key = Some(val.to_string());
        1713  +
        }
        1714  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
        1715  +
            builder.sse_customer_key_md5 = Some(val.to_string());
        1716  +
        }
        1717  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
        1718  +
            builder.ssekms_key_id = Some(val.to_string());
        1719  +
        }
        1720  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
        1721  +
            builder.ssekms_encryption_context = Some(val.to_string());
        1722  +
        }
        1723  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
        1724  +
            builder.bucket_key_enabled = val.parse::<bool>().ok();
        1725  +
        }
        1726  +
        if let Some(val) = headers.get("x-amz-copy-source-server-side-encryption-customer-algorithm") {
        1727  +
            builder.copy_source_sse_customer_algorithm = Some(val.to_string());
        1728  +
        }
        1729  +
        if let Some(val) = headers.get("x-amz-copy-source-server-side-encryption-customer-key") {
        1730  +
            builder.copy_source_sse_customer_key = Some(val.to_string());
        1731  +
        }
        1732  +
        if let Some(val) = headers.get("x-amz-copy-source-server-side-encryption-customer-key-MD5") {
        1733  +
            builder.copy_source_sse_customer_key_md5 = Some(val.to_string());
        1734  +
        }
        1735  +
        if let Some(val) = headers.get("x-amz-request-payer") {
        1736  +
            builder.request_payer = Some(crate::types::RequestPayer::from(val));
        1737  +
        }
        1738  +
        if let Some(val) = headers.get("x-amz-tagging") {
        1739  +
            builder.tagging = Some(val.to_string());
        1740  +
        }
        1741  +
        if let Some(val) = headers.get("x-amz-object-lock-mode") {
        1742  +
            builder.object_lock_mode = Some(crate::types::ObjectLockMode::from(val));
        1743  +
        }
        1744  +
        if let Some(val) = headers.get("x-amz-object-lock-retain-until-date") {
        1745  +
            builder.object_lock_retain_until_date = ::aws_smithy_types::DateTime::from_str(val, ::aws_smithy_types::date_time::Format::DateTime).ok();
        1746  +
        }
        1747  +
        if let Some(val) = headers.get("x-amz-object-lock-legal-hold") {
        1748  +
            builder.object_lock_legal_hold_status = Some(crate::types::ObjectLockLegalHoldStatus::from(val));
        1749  +
        }
        1750  +
        if let Some(val) = headers.get("x-amz-expected-bucket-owner") {
        1751  +
            builder.expected_bucket_owner = Some(val.to_string());
        1752  +
        }
        1753  +
        if let Some(val) = headers.get("x-amz-source-expected-bucket-owner") {
        1754  +
            builder.expected_source_bucket_owner = Some(val.to_string());
        1755  +
        }
        1756  +
        {
        1757  +
            let mut map = ::std::collections::HashMap::new();
        1758  +
            for (key, val) in headers.iter() {
        1759  +
                if let Some(suffix) = key.strip_prefix("x-amz-meta-") {
        1760  +
                    map.insert(suffix.to_string(), val.to_string());
        1761  +
                }
        1762  +
            }
        1763  +
            if !map.is_empty() {
        1764  +
                builder.metadata = Some(map);
        1765  +
            }
        1766  +
        }
        1767  +
        #[allow(
        1768  +
            unused_variables,
        1769  +
            unreachable_code,
        1770  +
            clippy::single_match,
        1771  +
            clippy::match_single_binding,
        1772  +
            clippy::diverging_sub_expression
        1773  +
        )]
        1774  +
        deserializer.read_struct(&COPYOBJECTINPUT_SCHEMA, &mut |member, deser| {
        1775  +
            match member.member_index() {
        1776  +
                Some(0) => { /* read from headers above */ }
        1777  +
                Some(1) => {
        1778  +
                    builder.bucket = Some(deser.read_string(member)?);
        1779  +
                }
        1780  +
                Some(2) => { /* read from headers above */ }
        1781  +
                Some(3) => { /* read from headers above */ }
        1782  +
                Some(4) => { /* read from headers above */ }
        1783  +
                Some(5) => { /* read from headers above */ }
        1784  +
                Some(6) => { /* read from headers above */ }
        1785  +
                Some(7) => { /* read from headers above */ }
        1786  +
                Some(8) => { /* read from headers above */ }
        1787  +
                Some(9) => { /* read from headers above */ }
        1788  +
                Some(10) => { /* read from headers above */ }
        1789  +
                Some(11) => { /* read from headers above */ }
        1790  +
                Some(12) => { /* read from headers above */ }
        1791  +
                Some(13) => { /* read from headers above */ }
        1792  +
                Some(14) => { /* read from headers above */ }
        1793  +
                Some(15) => { /* read from headers above */ }
        1794  +
                Some(16) => { /* read from headers above */ }
        1795  +
                Some(17) => { /* read from headers above */ }
        1796  +
                Some(18) => { /* read from headers above */ }
        1797  +
                Some(19) => { /* read from headers above */ }
        1798  +
                Some(20) => {
        1799  +
                    builder.key = Some(deser.read_string(member)?);
        1800  +
                }
        1801  +
                Some(21) => { /* read from headers above */ }
        1802  +
                Some(22) => { /* read from headers above */ }
        1803  +
                Some(23) => { /* read from headers above */ }
        1804  +
                Some(24) => { /* read from headers above */ }
        1805  +
                Some(25) => { /* read from headers above */ }
        1806  +
                Some(26) => { /* read from headers above */ }
        1807  +
                Some(27) => { /* read from headers above */ }
        1808  +
                Some(28) => { /* read from headers above */ }
        1809  +
                Some(29) => { /* read from headers above */ }
        1810  +
                Some(30) => { /* read from headers above */ }
        1811  +
                Some(31) => { /* read from headers above */ }
        1812  +
                Some(32) => { /* read from headers above */ }
        1813  +
                Some(33) => { /* read from headers above */ }
        1814  +
                Some(34) => { /* read from headers above */ }
        1815  +
                Some(35) => { /* read from headers above */ }
        1816  +
                Some(36) => { /* read from headers above */ }
        1817  +
                Some(37) => { /* read from headers above */ }
        1818  +
                Some(38) => { /* read from headers above */ }
        1819  +
                Some(39) => { /* read from headers above */ }
        1820  +
                Some(40) => { /* read from headers above */ }
        1821  +
                Some(41) => { /* read from headers above */ }
        1822  +
                Some(42) => { /* read from headers above */ }
        1823  +
                _ => {}
        1824  +
            }
        1825  +
            Ok(())
        1826  +
        })?;
 1623   1827   
        builder
 1624   1828   
            .build()
 1625   1829   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
 1626   1830   
    }
 1627   1831   
}
 1628   1832   
impl CopyObjectInput {
 1629   1833   
    /// Creates a new builder-style object to manufacture [`CopyObjectInput`](crate::operation::copy_object::CopyObjectInput).
 1630   1834   
    pub fn builder() -> crate::operation::copy_object::builders::CopyObjectInputBuilder {
 1631   1835   
        crate::operation::copy_object::builders::CopyObjectInputBuilder::default()
 1632   1836   
    }

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

@@ -106,106 +398,460 @@
  126    126   
    "com.amazonaws.s3.synthetic",
  127    127   
    "CopyObjectOutput",
  128    128   
);
  129    129   
static COPYOBJECTOUTPUT_MEMBER_COPY_OBJECT_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$CopyObjectResult",
  132    132   
        "com.amazonaws.s3.synthetic",
  133    133   
        "CopyObjectOutput",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136         -
    "copy_object_result",
         136  +
    "CopyObjectResult",
  137    137   
    0,
  138    138   
)
  139    139   
.with_http_payload();
  140    140   
static COPYOBJECTOUTPUT_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$Expiration",
  143    143   
        "com.amazonaws.s3.synthetic",
  144    144   
        "CopyObjectOutput",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "expiration",
         147  +
    "Expiration",
  148    148   
    1,
  149    149   
)
  150    150   
.with_http_header("x-amz-expiration");
  151    151   
static COPYOBJECTOUTPUT_MEMBER_COPY_SOURCE_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static(
  153    153   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$CopySourceVersionId",
  154    154   
        "com.amazonaws.s3.synthetic",
  155    155   
        "CopyObjectOutput",
  156    156   
    ),
  157    157   
    ::aws_smithy_schema::ShapeType::String,
  158         -
    "copy_source_version_id",
         158  +
    "CopySourceVersionId",
  159    159   
    2,
  160    160   
)
  161    161   
.with_http_header("x-amz-copy-source-version-id");
  162    162   
static COPYOBJECTOUTPUT_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  163    163   
    ::aws_smithy_schema::ShapeId::from_static(
  164    164   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$VersionId",
  165    165   
        "com.amazonaws.s3.synthetic",
  166    166   
        "CopyObjectOutput",
  167    167   
    ),
  168    168   
    ::aws_smithy_schema::ShapeType::String,
  169         -
    "version_id",
         169  +
    "VersionId",
  170    170   
    3,
  171    171   
)
  172    172   
.with_http_header("x-amz-version-id");
  173    173   
static COPYOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  174    174   
    ::aws_smithy_schema::ShapeId::from_static(
  175    175   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$ServerSideEncryption",
  176    176   
        "com.amazonaws.s3.synthetic",
  177    177   
        "CopyObjectOutput",
  178    178   
    ),
  179    179   
    ::aws_smithy_schema::ShapeType::String,
  180         -
    "server_side_encryption",
         180  +
    "ServerSideEncryption",
  181    181   
    4,
  182    182   
)
  183    183   
.with_http_header("x-amz-server-side-encryption");
  184    184   
static COPYOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$SSECustomerAlgorithm",
  187    187   
        "com.amazonaws.s3.synthetic",
  188    188   
        "CopyObjectOutput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::String,
  191         -
    "sse_customer_algorithm",
         191  +
    "SSECustomerAlgorithm",
  192    192   
    5,
  193    193   
)
  194    194   
.with_http_header("x-amz-server-side-encryption-customer-algorithm");
  195    195   
static COPYOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static(
  197    197   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$SSECustomerKeyMD5",
  198    198   
        "com.amazonaws.s3.synthetic",
  199    199   
        "CopyObjectOutput",
  200    200   
    ),
  201    201   
    ::aws_smithy_schema::ShapeType::String,
  202         -
    "sse_customer_key_md5",
         202  +
    "SSECustomerKeyMD5",
  203    203   
    6,
  204    204   
)
  205    205   
.with_http_header("x-amz-server-side-encryption-customer-key-MD5");
  206    206   
static COPYOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$SSEKMSKeyId",
  209    209   
        "com.amazonaws.s3.synthetic",
  210    210   
        "CopyObjectOutput",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::String,
  213         -
    "ssekms_key_id",
         213  +
    "SSEKMSKeyId",
  214    214   
    7,
  215    215   
)
  216    216   
.with_http_header("x-amz-server-side-encryption-aws-kms-key-id");
  217    217   
static COPYOBJECTOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    218   
    ::aws_smithy_schema::ShapeId::from_static(
  219    219   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$SSEKMSEncryptionContext",
  220    220   
        "com.amazonaws.s3.synthetic",
  221    221   
        "CopyObjectOutput",
  222    222   
    ),
  223    223   
    ::aws_smithy_schema::ShapeType::String,
  224         -
    "ssekms_encryption_context",
         224  +
    "SSEKMSEncryptionContext",
  225    225   
    8,
  226    226   
)
  227    227   
.with_http_header("x-amz-server-side-encryption-context");
  228    228   
static COPYOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  229    229   
    ::aws_smithy_schema::ShapeId::from_static(
  230    230   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$BucketKeyEnabled",
  231    231   
        "com.amazonaws.s3.synthetic",
  232    232   
        "CopyObjectOutput",
  233    233   
    ),
  234    234   
    ::aws_smithy_schema::ShapeType::Boolean,
  235         -
    "bucket_key_enabled",
         235  +
    "BucketKeyEnabled",
  236    236   
    9,
  237    237   
)
  238    238   
.with_http_header("x-amz-server-side-encryption-bucket-key-enabled");
  239    239   
static COPYOBJECTOUTPUT_MEMBER_REQUEST_CHARGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  240    240   
    ::aws_smithy_schema::ShapeId::from_static(
  241    241   
        "com.amazonaws.s3.synthetic#CopyObjectOutput$RequestCharged",
  242    242   
        "com.amazonaws.s3.synthetic",
  243    243   
        "CopyObjectOutput",
  244    244   
    ),
  245    245   
    ::aws_smithy_schema::ShapeType::String,
  246         -
    "request_charged",
         246  +
    "RequestCharged",
  247    247   
    10,
  248    248   
)
  249    249   
.with_http_header("x-amz-request-charged");
         250  +
static COPYOBJECTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         251  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         252  +
    ::aws_smithy_schema::ShapeType::String,
         253  +
    "request_id",
         254  +
    11,
         255  +
)
         256  +
.with_http_header("x-amzn-requestid");
  250    257   
static COPYOBJECTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  251    258   
    COPYOBJECTOUTPUT_SCHEMA_ID,
  252    259   
    ::aws_smithy_schema::ShapeType::Structure,
  253    260   
    &[
  254    261   
        &COPYOBJECTOUTPUT_MEMBER_COPY_OBJECT_RESULT,
  255    262   
        &COPYOBJECTOUTPUT_MEMBER_EXPIRATION,
  256    263   
        &COPYOBJECTOUTPUT_MEMBER_COPY_SOURCE_VERSION_ID,
  257    264   
        &COPYOBJECTOUTPUT_MEMBER_VERSION_ID,
  258    265   
        &COPYOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION,
  259    266   
        &COPYOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM,
  260    267   
        &COPYOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5,
  261    268   
        &COPYOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID,
  262    269   
        &COPYOBJECTOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT,
  263    270   
        &COPYOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED,
  264    271   
        &COPYOBJECTOUTPUT_MEMBER_REQUEST_CHARGED,
         272  +
        &COPYOBJECTOUTPUT_MEMBER__REQUEST_ID,
  265    273   
    ],
  266    274   
);
  267    275   
impl CopyObjectOutput {
  268    276   
    /// The schema for this shape.
  269    277   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COPYOBJECTOUTPUT_SCHEMA;
  270    278   
}
  271    279   
impl ::aws_smithy_schema::serde::SerializableStruct for CopyObjectOutput {
  272    280   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  273    281   
    fn serialize_members(
  274    282   
        &self,
  275    283   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  276    284   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  277    285   
        if let Some(ref val) = self.copy_object_result {
  278    286   
            ser.write_struct(&COPYOBJECTOUTPUT_MEMBER_COPY_OBJECT_RESULT, val)?;
  279    287   
        }
  280    288   
        if let Some(ref val) = self.expiration {
  281    289   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_EXPIRATION, val)?;
  282    290   
        }
  283    291   
        if let Some(ref val) = self.copy_source_version_id {
  284    292   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_COPY_SOURCE_VERSION_ID, val)?;
  285    293   
        }
  286    294   
        if let Some(ref val) = self.version_id {
  287    295   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_VERSION_ID, val)?;
  288    296   
        }
  289    297   
        if let Some(ref val) = self.server_side_encryption {
  290    298   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_SERVER_SIDE_ENCRYPTION, val.as_str())?;
  291    299   
        }
  292    300   
        if let Some(ref val) = self.sse_customer_algorithm {
  293    301   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_ALGORITHM, val)?;
  294    302   
        }
  295    303   
        if let Some(ref val) = self.sse_customer_key_md5 {
  296    304   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_SSE_CUSTOMER_KEY_MD5, val)?;
  297    305   
        }
  298    306   
        if let Some(ref val) = self.ssekms_key_id {
  299    307   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_SSEKMS_KEY_ID, val)?;
  300    308   
        }
  301    309   
        if let Some(ref val) = self.ssekms_encryption_context {
  302    310   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_SSEKMS_ENCRYPTION_CONTEXT, val)?;
  303    311   
        }
  304    312   
        if let Some(ref val) = self.bucket_key_enabled {
  305    313   
            ser.write_boolean(&COPYOBJECTOUTPUT_MEMBER_BUCKET_KEY_ENABLED, *val)?;
  306    314   
        }
  307    315   
        if let Some(ref val) = self.request_charged {
  308    316   
            ser.write_string(&COPYOBJECTOUTPUT_MEMBER_REQUEST_CHARGED, val.as_str())?;
  309    317   
        }
  310    318   
        Ok(())
  311    319   
    }
  312    320   
}
  313    321   
impl CopyObjectOutput {
  314    322   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  315         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  316         -
        deserializer: &mut D,
         323  +
    pub fn deserialize(
         324  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  317    325   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  318    326   
        #[allow(unused_variables, unused_mut)]
  319    327   
        let mut builder = Self::builder();
  320    328   
        #[allow(
  321    329   
            unused_variables,
  322    330   
            unreachable_code,
  323    331   
            clippy::single_match,
  324    332   
            clippy::match_single_binding,
  325    333   
            clippy::diverging_sub_expression
  326    334   
        )]
  327         -
        deserializer.read_struct(&COPYOBJECTOUTPUT_SCHEMA, (), |_, member, deser| {
         335  +
        deserializer.read_struct(&COPYOBJECTOUTPUT_SCHEMA, &mut |member, deser| {
  328    336   
            match member.member_index() {
  329    337   
                Some(0) => {
  330    338   
                    builder.copy_object_result = Some(crate::types::CopyObjectResult::deserialize(deser)?);
  331    339   
                }
  332    340   
                Some(1) => {
  333    341   
                    builder.expiration = Some(deser.read_string(member)?);
  334    342   
                }
  335    343   
                Some(2) => {
  336    344   
                    builder.copy_source_version_id = Some(deser.read_string(member)?);
  337    345   
                }
  338    346   
                Some(3) => {
  339    347   
                    builder.version_id = Some(deser.read_string(member)?);
  340    348   
                }
  341    349   
                Some(4) => {
  342    350   
                    builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(deser.read_string(member)?.as_str()));
  343    351   
                }
  344    352   
                Some(5) => {
  345    353   
                    builder.sse_customer_algorithm = Some(deser.read_string(member)?);
  346    354   
                }
  347    355   
                Some(6) => {
  348    356   
                    builder.sse_customer_key_md5 = Some(deser.read_string(member)?);
  349    357   
                }
  350    358   
                Some(7) => {
  351    359   
                    builder.ssekms_key_id = Some(deser.read_string(member)?);
  352    360   
                }
  353    361   
                Some(8) => {
  354    362   
                    builder.ssekms_encryption_context = Some(deser.read_string(member)?);
  355    363   
                }
  356    364   
                Some(9) => {
  357    365   
                    builder.bucket_key_enabled = Some(deser.read_boolean(member)?);
  358    366   
                }
  359    367   
                Some(10) => {
  360    368   
                    builder.request_charged = Some(crate::types::RequestCharged::from(deser.read_string(member)?.as_str()));
  361    369   
                }
         370  +
                Some(11) => {
         371  +
                    builder._request_id = Some(deser.read_string(member)?);
         372  +
                }
  362    373   
                _ => {}
  363    374   
            }
  364    375   
            Ok(())
  365    376   
        })?;
  366    377   
        Ok(builder.build())
  367    378   
    }
  368    379   
}
         380  +
impl CopyObjectOutput {
         381  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         382  +
    /// Header-bound members are read directly from headers, avoiding runtime
         383  +
    /// member iteration overhead. Body members are read via the deserializer.
         384  +
    pub fn deserialize_with_response(
         385  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         386  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         387  +
        _status: u16,
         388  +
        body: &[u8],
         389  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         390  +
        #[allow(unused_variables, unused_mut)]
         391  +
        let mut builder = Self::builder();
         392  +
        if let Some(val) = headers.get("x-amz-expiration") {
         393  +
            builder.expiration = Some(val.to_string());
         394  +
        }
         395  +
        if let Some(val) = headers.get("x-amz-copy-source-version-id") {
         396  +
            builder.copy_source_version_id = Some(val.to_string());
         397  +
        }
         398  +
        if let Some(val) = headers.get("x-amz-version-id") {
         399  +
            builder.version_id = Some(val.to_string());
         400  +
        }
         401  +
        if let Some(val) = headers.get("x-amz-server-side-encryption") {
         402  +
            builder.server_side_encryption = Some(crate::types::ServerSideEncryption::from(val));
         403  +
        }
         404  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-algorithm") {
         405  +
            builder.sse_customer_algorithm = Some(val.to_string());
         406  +
        }
         407  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-customer-key-MD5") {
         408  +
            builder.sse_customer_key_md5 = Some(val.to_string());
         409  +
        }
         410  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-aws-kms-key-id") {
         411  +
            builder.ssekms_key_id = Some(val.to_string());
         412  +
        }
         413  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-context") {
         414  +
            builder.ssekms_encryption_context = Some(val.to_string());
         415  +
        }
         416  +
        if let Some(val) = headers.get("x-amz-server-side-encryption-bucket-key-enabled") {
         417  +
            builder.bucket_key_enabled = val.parse::<bool>().ok();
         418  +
        }
         419  +
        if let Some(val) = headers.get("x-amz-request-charged") {
         420  +
            builder.request_charged = Some(crate::types::RequestCharged::from(val));
         421  +
        }
         422  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         423  +
            builder._request_id = Some(val.to_string());
         424  +
        }
         425  +
        if !body.is_empty() {
         426  +
            builder.copy_object_result = Some(crate::types::CopyObjectResult::deserialize(deserializer)?);
         427  +
        }
         428  +
        Ok(builder.build())
         429  +
    }
         430  +
}
  369    431   
impl crate::s3_request_id::RequestIdExt for CopyObjectOutput {
  370    432   
    fn extended_request_id(&self) -> Option<&str> {
  371    433   
        self._extended_request_id.as_deref()
  372    434   
    }
  373    435   
}
  374    436   
impl ::aws_types::request_id::RequestId for CopyObjectOutput {
  375    437   
    fn request_id(&self) -> Option<&str> {
  376    438   
        self._request_id.as_deref()
  377    439   
    }
  378    440   
}