AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/error/_service_unavailable_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&SERVICEUNAVAILABLEEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ServiceUnavailableException {
   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(&SERVICEUNAVAILABLEEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&SERVICEUNAVAILABLEEXCEPTION_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 ServiceUnavailableException {
          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 ServiceUnavailableException {
   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 ServiceUnavailableException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ServiceUnavailableException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/error/_session_streaming_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&SESSIONSTREAMINGEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl SessionStreamingException {
   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(&SESSIONSTREAMINGEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&SESSIONSTREAMINGEXCEPTION_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 SessionStreamingException {
          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 SessionStreamingException {
   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 SessionStreamingException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "SessionStreamingException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/error/_session_timeout_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&SESSIONTIMEOUTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl SessionTimeoutException {
   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(&SESSIONTIMEOUTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&SESSIONTIMEOUTEXCEPTION_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 SessionTimeoutException {
          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 SessionTimeoutException {
   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 SessionTimeoutException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "SessionTimeoutException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

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

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/error/_too_many_tags_exception.rs

@@ -11,11 +126,137 @@
   31     31   
    "message",
   32     32   
    0,
   33     33   
);
   34     34   
static TOOMANYTAGSEXCEPTION_MEMBER_RESOURCE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.cloudwatchlogs#TooManyTagsException$resourceName",
   37     37   
        "com.amazonaws.cloudwatchlogs",
   38     38   
        "TooManyTagsException",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "resource_name",
          41  +
    "resourceName",
   42     42   
    1,
   43     43   
);
   44     44   
static TOOMANYTAGSEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    TOOMANYTAGSEXCEPTION_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&TOOMANYTAGSEXCEPTION_MEMBER_MESSAGE, &TOOMANYTAGSEXCEPTION_MEMBER_RESOURCE_NAME],
   48     48   
);
   49     49   
impl TooManyTagsException {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TOOMANYTAGSEXCEPTION_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for TooManyTagsException {
   54     54   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   55     55   
    fn serialize_members(
   56     56   
        &self,
   57     57   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   58     58   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        if let Some(ref val) = self.message {
   60     60   
            ser.write_string(&TOOMANYTAGSEXCEPTION_MEMBER_MESSAGE, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.resource_name {
   63     63   
            ser.write_string(&TOOMANYTAGSEXCEPTION_MEMBER_RESOURCE_NAME, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl TooManyTagsException {
   69     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   70         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   71         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   72     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        #[allow(unused_variables, unused_mut)]
   74     74   
        let mut builder = Self::builder();
   75     75   
        #[allow(
   76     76   
            unused_variables,
   77     77   
            unreachable_code,
   78     78   
            clippy::single_match,
   79     79   
            clippy::match_single_binding,
   80     80   
            clippy::diverging_sub_expression
   81     81   
        )]
   82         -
        deserializer.read_struct(&TOOMANYTAGSEXCEPTION_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&TOOMANYTAGSEXCEPTION_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.message = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.resource_name = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl TooManyTagsException {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   97    108   
impl TooManyTagsException {
   98    109   
    /// Returns the error message.
   99    110   
    pub fn message(&self) -> ::std::option::Option<&str> {
  100    111   
        self.message.as_deref()
  101    112   
    }
  102    113   
}
  103    114   
impl ::std::fmt::Display for TooManyTagsException {
  104    115   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  105    116   
        ::std::write!(f, "TooManyTagsException")?;
  106    117   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/error/_unrecognized_client_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&UNRECOGNIZEDCLIENTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl UnrecognizedClientException {
   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(&UNRECOGNIZEDCLIENTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&UNRECOGNIZEDCLIENTEXCEPTION_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 UnrecognizedClientException {
          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 UnrecognizedClientException {
   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 UnrecognizedClientException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "UnrecognizedClientException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/error/_validation_exception.rs

@@ -19,19 +102,113 @@
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&VALIDATIONEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ValidationException {
   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(&VALIDATIONEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&VALIDATIONEXCEPTION_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 ValidationException {
          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 ValidationException {
   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 ValidationException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ValidationException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -15,15 +80,80 @@
   35     35   
path = "../aws-smithy-json"
   36     36   
version = "0.62.6"
   37     37   
   38     38   
[dependencies.aws-smithy-observability]
   39     39   
path = "../aws-smithy-observability"
   40     40   
version = "0.2.6"
   41     41   
   42     42   
[dependencies.aws-smithy-runtime]
   43     43   
path = "../aws-smithy-runtime"
   44     44   
features = ["client", "http-auth"]
   45         -
version = "1.10.3"
          45  +
version = "1.10.4"
   46     46   
   47     47   
[dependencies.aws-smithy-runtime-api]
   48     48   
path = "../aws-smithy-runtime-api"
   49     49   
features = ["client", "http-1x", "http-auth"]
   50         -
version = "1.11.6"
          50  +
version = "1.11.7"
   51     51   
   52     52   
[dependencies.aws-smithy-schema]
   53     53   
path = "../aws-smithy-schema"
   54     54   
version = "1.0.0"
   55     55   
   56     56   
[dependencies.aws-smithy-types]
   57     57   
path = "../aws-smithy-types"
   58     58   
features = ["http-body-1-x"]
   59     59   
version = "1.4.7"
   60     60
@@ -84,84 +149,149 @@
  104    104   
features = ["test-util", "wire-mock"]
  105    105   
version = "1.1.12"
  106    106   
  107    107   
[dev-dependencies.aws-smithy-protocol-test]
  108    108   
path = "../aws-smithy-protocol-test"
  109    109   
version = "0.63.14"
  110    110   
  111    111   
[dev-dependencies.aws-smithy-runtime]
  112    112   
path = "../aws-smithy-runtime"
  113    113   
features = ["test-util"]
  114         -
version = "1.10.3"
         114  +
version = "1.10.4"
  115    115   
  116    116   
[dev-dependencies.aws-smithy-runtime-api]
  117    117   
path = "../aws-smithy-runtime-api"
  118    118   
features = ["test-util"]
  119         -
version = "1.11.6"
         119  +
version = "1.11.7"
  120    120   
  121    121   
[dev-dependencies.aws-smithy-types]
  122    122   
path = "../aws-smithy-types"
  123    123   
features = ["http-body-1-x", "test-util"]
  124    124   
version = "1.4.7"
  125    125   
  126    126   
[dev-dependencies.futures-util]
  127    127   
version = "0.3.25"
  128    128   
features = ["alloc"]
  129    129   
default-features = false

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/config.rs

@@ -23,23 +82,86 @@
   43     43   
            config: self.cloneable.clone(),
   44     44   
            runtime_components: self.runtime_components.clone(),
   45     45   
            runtime_plugins: self.runtime_plugins.clone(),
   46     46   
            behavior_version: self.behavior_version,
   47     47   
        }
   48     48   
    }
   49     49   
    /// Return a reference to the stalled stream protection configuration contained in this config, if any.
   50     50   
    pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
   51     51   
        self.config.load::<crate::config::StalledStreamProtectionConfig>()
   52     52   
    }
          53  +
    /// Returns the client protocol used for serialization and deserialization.
          54  +
    pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
          55  +
        self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
          56  +
    }
   53     57   
    /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
   54     58   
    pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
   55     59   
        self.runtime_components.http_client()
   56     60   
    }
   57     61   
    /// Return the auth schemes configured on this service config
   58     62   
    pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
   59     63   
        self.runtime_components.auth_schemes()
   60     64   
    }
   61     65   
   62     66   
    /// Return the auth scheme resolver configured on this service config
@@ -139,143 +239,262 @@
  159    163   
    ///
  160    164   
    pub fn new() -> Self {
  161    165   
        Self::default()
  162    166   
    }
  163    167   
    /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
  164    168   
    /// but not those in runtime components.
  165    169   
    #[allow(unused)]
  166    170   
    pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
  167    171   
        let mut builder = Self::new();
  168    172   
        builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         173  +
        if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
         174  +
            builder.set_protocol(::std::option::Option::Some(protocol));
         175  +
        }
  169    176   
        builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
  170    177   
        builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
  171    178   
        builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
  172    179   
        builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
  173    180   
        builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
  174    181   
        builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
  175    182   
        builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
  176    183   
        builder.set_region(config_bag.load::<crate::config::Region>().cloned());
  177    184   
        builder
  178    185   
    }
  179    186   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  180    187   
    /// to configure protection for stalled streams.
  181    188   
    pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
  182    189   
        self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
  183    190   
        self
  184    191   
    }
  185    192   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  186    193   
    /// to configure protection for stalled streams.
  187    194   
    pub fn set_stalled_stream_protection(
  188    195   
        &mut self,
  189    196   
        stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
  190    197   
    ) -> &mut Self {
  191    198   
        self.config.store_or_unset(stalled_stream_protection_config);
  192    199   
        self
  193    200   
    }
  194    201   
    /// Sets the idempotency token provider to use for service calls that require tokens.
  195    202   
    pub fn idempotency_token_provider(
  196    203   
        mut self,
  197    204   
        idempotency_token_provider: impl ::std::convert::Into<crate::idempotency_token::IdempotencyTokenProvider>,
  198    205   
    ) -> Self {
  199    206   
        self.set_idempotency_token_provider(::std::option::Option::Some(idempotency_token_provider.into()));
  200    207   
        self
  201    208   
    }
  202    209   
    /// Sets the idempotency token provider to use for service calls that require tokens.
  203    210   
    pub fn set_idempotency_token_provider(
  204    211   
        &mut self,
  205    212   
        idempotency_token_provider: ::std::option::Option<crate::idempotency_token::IdempotencyTokenProvider>,
  206    213   
    ) -> &mut Self {
  207    214   
        self.config.store_or_unset(idempotency_token_provider);
  208    215   
        self
  209    216   
    }
         217  +
    /// Sets the client protocol to use for serialization and deserialization.
         218  +
    ///
         219  +
    /// This overrides the default protocol determined by the service model,
         220  +
    /// enabling runtime protocol selection.
         221  +
    pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         222  +
        self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
         223  +
            protocol,
         224  +
        )));
         225  +
        self
         226  +
    }
         227  +
         228  +
    /// Sets the client protocol to use for serialization and deserialization.
         229  +
    pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         230  +
        self.config.store_or_unset(protocol);
         231  +
        self
         232  +
    }
  210    233   
    /// Sets the HTTP client to use when making requests.
  211    234   
    ///
  212    235   
    /// # Examples
  213    236   
    /// ```no_run
  214    237   
    /// # #[cfg(test)]
  215    238   
    /// # mod tests {
  216    239   
    /// # #[test]
  217    240   
    /// # fn example() {
  218    241   
    /// use std::time::Duration;
  219    242   
    /// use aws_sdk_codecatalyst::config::Config;
@@ -1288,1311 +1347,1375 @@
 1308   1331   
pub(crate) struct ServiceRuntimePlugin {
 1309   1332   
    config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
 1310   1333   
    runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1311   1334   
}
 1312   1335   
 1313   1336   
impl ServiceRuntimePlugin {
 1314   1337   
    pub fn new(_service_config: crate::config::Config) -> Self {
 1315   1338   
        let config = {
 1316   1339   
            let mut cfg = ::aws_smithy_types::config_bag::Layer::new("CodeCatalyst");
 1317   1340   
            cfg.store_put(crate::idempotency_token::default_provider());
        1341  +
            if _service_config.protocol().is_none() {
        1342  +
                cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
        1343  +
                    ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
        1344  +
                ));
        1345  +
            }
 1318   1346   
            cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
 1319   1347   
            ::std::option::Option::Some(cfg.freeze())
 1320   1348   
        };
 1321   1349   
        let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
 1322   1350   
        runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
 1323   1351   
            ::aws_smithy_runtime::client::auth::http::BearerAuthScheme::new(),
 1324   1352   
        ));
 1325   1353   
        runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
 1326   1354   
            use crate::config::auth::ResolveAuthScheme;
 1327   1355   
            crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
@@ -1413,1441 +1472,1503 @@
 1433   1461   
        }
 1434   1462   
        // resiliency
 1435   1463   
        builder.set_retry_config(input.retry_config().cloned());
 1436   1464   
        builder.set_timeout_config(input.timeout_config().cloned());
 1437   1465   
        builder.set_sleep_impl(input.sleep_impl());
 1438   1466   
 1439   1467   
        builder.set_http_client(input.http_client());
 1440   1468   
        builder.set_time_source(input.time_source());
 1441   1469   
        builder.set_behavior_version(input.behavior_version());
 1442   1470   
        builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
        1471  +
        if let Some(protocol) = input.protocol() {
        1472  +
            builder.set_protocol(Some(protocol.clone()));
        1473  +
        }
 1443   1474   
        // setting `None` here removes the default
 1444   1475   
        if let Some(config) = input.stalled_stream_protection() {
 1445   1476   
            builder.set_stalled_stream_protection(Some(config));
 1446   1477   
        }
 1447   1478   
 1448   1479   
        if let Some(cache) = input.identity_cache() {
 1449   1480   
            builder.set_identity_cache(cache);
 1450   1481   
        }
 1451   1482   
        builder.set_token_provider(input.token_provider());
 1452   1483   
        builder.set_app_name(input.app_name().cloned());

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/lib.rs

@@ -222,222 +263,259 @@
  242    242   
pub(crate) mod client_idempotency_token;
  243    243   
  244    244   
mod idempotency_token;
  245    245   
  246    246   
mod observability_feature;
  247    247   
  248    248   
pub(crate) mod protocol_serde;
  249    249   
  250    250   
mod sdk_feature_tracker;
  251    251   
  252         -
mod serialization_settings;
  253         -
  254    252   
mod endpoint_lib;
  255    253   
  256         -
mod lens;
  257         -
  258         -
mod serde_util;
  259         -
  260    254   
mod json_errors;
  261    255   
         256  +
mod lens;
         257  +
  262    258   
#[doc(inline)]
  263    259   
pub use client::Client;

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_access_token.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 `CreateAccessToken`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateAccessToken;
    6      6   
impl CreateAccessToken {
    7      7   
    /// Creates a new `CreateAccessToken`
    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::create_access_token::CreateAccessTokenInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_access_token::CreateAccessTokenOutput::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::create_access_token::CreateAccessTokenInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::create_access_token::CreateAccessTokenOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::create_access_token::CreateAccessTokenError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -109,113 +231,379 @@
  129    133   
                crate::operation::create_access_token::CreateAccessTokenError,
  130    134   
            >::new());
  131    135   
  132    136   
        ::std::borrow::Cow::Owned(rcb)
  133    137   
    }
  134    138   
}
  135    139   
  136    140   
#[derive(Debug)]
  137    141   
struct CreateAccessTokenResponseDeserializer;
  138    142   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateAccessTokenResponseDeserializer {
  139         -
    fn deserialize_nonstreaming(
         143  +
    fn deserialize_nonstreaming_with_config(
  140    144   
        &self,
  141    145   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         146  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  142    147   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  143    148   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  144         -
        let headers = response.headers();
  145         -
        let body = response.body().bytes().expect("body loaded");
  146    149   
        #[allow(unused_mut)]
  147    150   
        let mut force_error = false;
  148    151   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  149         -
        let parse_result = if !success && status != 201 || force_error {
  150         -
            crate::protocol_serde::shape_create_access_token::de_create_access_token_http_error(status, headers, body)
         152  +
        if !success && status != 201 || force_error {
         153  +
            let headers = response.headers();
         154  +
            let body = response.body().bytes().expect("body loaded");
         155  +
            #[allow(unused_mut)]
         156  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         157  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         158  +
            })?;
         159  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         160  +
            let generic = generic_builder.build();
         161  +
            let error_code = match generic.code() {
         162  +
                ::std::option::Option::Some(code) => code,
         163  +
                ::std::option::Option::None => {
         164  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         165  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         166  +
                            crate::operation::create_access_token::CreateAccessTokenError::unhandled(generic),
         167  +
                        ),
         168  +
                    ))
         169  +
                }
         170  +
            };
         171  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         172  +
            let protocol = _cfg
         173  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         174  +
                .expect("a SharedClientProtocol is required");
         175  +
            let err = match error_code {
         176  +
                "AccessDeniedException" => crate::operation::create_access_token::CreateAccessTokenError::AccessDeniedException({
         177  +
                    let mut tmp = match protocol
         178  +
                        .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
         179  +
                        .and_then(|mut deser| {
         180  +
                            crate::types::error::AccessDeniedException::deserialize_with_response(
         181  +
                                &mut *deser,
         182  +
                                response.headers(),
         183  +
                                response.status().into(),
         184  +
                                body,
         185  +
                            )
         186  +
                        }) {
         187  +
                        ::std::result::Result::Ok(val) => val,
         188  +
                        ::std::result::Result::Err(e) => {
         189  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         190  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         191  +
                            ))
         192  +
                        }
         193  +
                    };
         194  +
                    tmp.meta = generic;
         195  +
                    tmp
         196  +
                }),
         197  +
                "ConflictException" => crate::operation::create_access_token::CreateAccessTokenError::ConflictException({
         198  +
                    let mut tmp = match protocol
         199  +
                        .deserialize_response(response, crate::types::error::ConflictException::SCHEMA, _cfg)
         200  +
                        .and_then(|mut deser| {
         201  +
                            crate::types::error::ConflictException::deserialize_with_response(
         202  +
                                &mut *deser,
         203  +
                                response.headers(),
         204  +
                                response.status().into(),
         205  +
                                body,
         206  +
                            )
         207  +
                        }) {
         208  +
                        ::std::result::Result::Ok(val) => val,
         209  +
                        ::std::result::Result::Err(e) => {
         210  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         211  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         212  +
                            ))
         213  +
                        }
         214  +
                    };
         215  +
                    tmp.meta = generic;
         216  +
                    tmp
         217  +
                }),
         218  +
                "ResourceNotFoundException" => crate::operation::create_access_token::CreateAccessTokenError::ResourceNotFoundException({
         219  +
                    let mut tmp = match protocol
         220  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         221  +
                        .and_then(|mut deser| {
         222  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         223  +
                                &mut *deser,
         224  +
                                response.headers(),
         225  +
                                response.status().into(),
         226  +
                                body,
         227  +
                            )
         228  +
                        }) {
         229  +
                        ::std::result::Result::Ok(val) => val,
         230  +
                        ::std::result::Result::Err(e) => {
         231  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         232  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         233  +
                            ))
         234  +
                        }
         235  +
                    };
         236  +
                    tmp.meta = generic;
         237  +
                    tmp
         238  +
                }),
         239  +
                "ServiceQuotaExceededException" => crate::operation::create_access_token::CreateAccessTokenError::ServiceQuotaExceededException({
         240  +
                    let mut tmp = match protocol
         241  +
                        .deserialize_response(response, crate::types::error::ServiceQuotaExceededException::SCHEMA, _cfg)
         242  +
                        .and_then(|mut deser| {
         243  +
                            crate::types::error::ServiceQuotaExceededException::deserialize_with_response(
         244  +
                                &mut *deser,
         245  +
                                response.headers(),
         246  +
                                response.status().into(),
         247  +
                                body,
         248  +
                            )
         249  +
                        }) {
         250  +
                        ::std::result::Result::Ok(val) => val,
         251  +
                        ::std::result::Result::Err(e) => {
         252  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         253  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         254  +
                            ))
         255  +
                        }
         256  +
                    };
         257  +
                    tmp.meta = generic;
         258  +
                    tmp
         259  +
                }),
         260  +
                "ThrottlingException" => crate::operation::create_access_token::CreateAccessTokenError::ThrottlingException({
         261  +
                    let mut tmp = match protocol
         262  +
                        .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
         263  +
                        .and_then(|mut deser| {
         264  +
                            crate::types::error::ThrottlingException::deserialize_with_response(
         265  +
                                &mut *deser,
         266  +
                                response.headers(),
         267  +
                                response.status().into(),
         268  +
                                body,
         269  +
                            )
         270  +
                        }) {
         271  +
                        ::std::result::Result::Ok(val) => val,
         272  +
                        ::std::result::Result::Err(e) => {
         273  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         274  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         275  +
                            ))
         276  +
                        }
         277  +
                    };
         278  +
                    tmp.meta = generic;
         279  +
                    tmp
         280  +
                }),
         281  +
                "ValidationException" => crate::operation::create_access_token::CreateAccessTokenError::ValidationException({
         282  +
                    let mut tmp = match protocol
         283  +
                        .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
         284  +
                        .and_then(|mut deser| {
         285  +
                            crate::types::error::ValidationException::deserialize_with_response(
         286  +
                                &mut *deser,
         287  +
                                response.headers(),
         288  +
                                response.status().into(),
         289  +
                                body,
         290  +
                            )
         291  +
                        }) {
         292  +
                        ::std::result::Result::Ok(val) => val,
         293  +
                        ::std::result::Result::Err(e) => {
         294  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         295  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         296  +
                            ))
         297  +
                        }
         298  +
                    };
         299  +
                    tmp.meta = generic;
         300  +
                    tmp
         301  +
                }),
         302  +
                _ => crate::operation::create_access_token::CreateAccessTokenError::generic(generic),
         303  +
            };
         304  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         305  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         306  +
            ))
  151    307   
        } else {
  152         -
            crate::protocol_serde::shape_create_access_token::de_create_access_token_http_response(status, headers, body)
  153         -
        };
  154         -
        crate::protocol_serde::type_erase_result(parse_result)
         308  +
            let protocol = _cfg
         309  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         310  +
                .expect("a SharedClientProtocol is required");
         311  +
            let mut deser = protocol
         312  +
                .deserialize_response(response, CreateAccessToken::OUTPUT_SCHEMA, _cfg)
         313  +
                .map_err(|e| {
         314  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         315  +
                })?;
         316  +
            let body = response.body().bytes().expect("body loaded");
         317  +
            let output = crate::operation::create_access_token::CreateAccessTokenOutput::deserialize_with_response(
         318  +
                &mut *deser,
         319  +
                response.headers(),
         320  +
                response.status().into(),
         321  +
                body,
         322  +
            )
         323  +
            .map_err(|e| {
         324  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         325  +
            })?;
         326  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         327  +
        }
  155    328   
    }
  156    329   
}
  157    330   
#[derive(Debug)]
  158    331   
struct CreateAccessTokenRequestSerializer;
  159    332   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateAccessTokenRequestSerializer {
  160    333   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  161    334   
    fn serialize_input(
  162    335   
        &self,
  163    336   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  164    337   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  165    338   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  166    339   
        let input = input
  167    340   
            .downcast::<crate::operation::create_access_token::CreateAccessTokenInput>()
  168    341   
            .expect("correct type");
  169         -
        let _header_serialization_settings = _cfg
  170         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  171         -
            .cloned()
  172         -
            .unwrap_or_default();
  173         -
        let mut request_builder = {
  174         -
            #[allow(clippy::uninlined_format_args)]
  175         -
            fn uri_base(
  176         -
                _input: &crate::operation::create_access_token::CreateAccessTokenInput,
  177         -
                output: &mut ::std::string::String,
  178         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  179         -
                use ::std::fmt::Write as _;
  180         -
                ::std::write!(output, "/v1/accessTokens").expect("formatting should succeed");
  181         -
                ::std::result::Result::Ok(())
  182         -
            }
  183         -
            #[allow(clippy::unnecessary_wraps)]
  184         -
            fn update_http_builder(
  185         -
                input: &crate::operation::create_access_token::CreateAccessTokenInput,
  186         -
                builder: ::http_1x::request::Builder,
  187         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  188         -
                let mut uri = ::std::string::String::new();
  189         -
                uri_base(input, &mut uri)?;
  190         -
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  191         -
            }
  192         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  193         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  194         -
            builder
  195         -
        };
  196         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_access_token::ser_create_access_token_input(&input)?);
  197         -
        if let Some(content_length) = body.content_length() {
  198         -
            let content_length = content_length.to_string();
  199         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  200         -
        }
  201         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         342  +
        let protocol = _cfg
         343  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         344  +
            .expect("a SharedClientProtocol is required");
         345  +
        let mut request = protocol
         346  +
            .serialize_request(&input, CreateAccessToken::INPUT_SCHEMA, "", _cfg)
         347  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         348  +
         349  +
        return ::std::result::Result::Ok(request);
  202    350   
    }
  203    351   
}
  204    352   
#[derive(Debug)]
  205    353   
struct CreateAccessTokenEndpointParamsInterceptor;
  206    354   
  207    355   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateAccessTokenEndpointParamsInterceptor {
  208    356   
    fn name(&self) -> &'static str {
  209    357   
        "CreateAccessTokenEndpointParamsInterceptor"
  210    358   
    }
  211    359

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_access_token/_create_access_token_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_access_token/_create_access_token_output.rs

@@ -50,50 +177,237 @@
   70     70   
    "name",
   71     71   
    1,
   72     72   
);
   73     73   
static CREATEACCESSTOKENOUTPUT_MEMBER_EXPIRES_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.codecatalyst.synthetic#CreateAccessTokenOutput$expiresTime",
   76     76   
        "com.amazonaws.codecatalyst.synthetic",
   77     77   
        "CreateAccessTokenOutput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Timestamp,
   80         -
    "expires_time",
          80  +
    "expiresTime",
   81     81   
    2,
   82     82   
)
   83     83   
.with_timestamp_format(aws_smithy_schema::traits::TimestampFormat::DateTime);
   84     84   
static CREATEACCESSTOKENOUTPUT_MEMBER_ACCESS_TOKEN_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.codecatalyst.synthetic#CreateAccessTokenOutput$accessTokenId",
   87     87   
        "com.amazonaws.codecatalyst.synthetic",
   88     88   
        "CreateAccessTokenOutput",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "access_token_id",
          91  +
    "accessTokenId",
   92     92   
    3,
   93     93   
);
          94  +
static CREATEACCESSTOKENOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          95  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          96  +
    ::aws_smithy_schema::ShapeType::String,
          97  +
    "request_id",
          98  +
    4,
          99  +
)
         100  +
.with_http_header("x-amzn-requestid");
   94    101   
static CREATEACCESSTOKENOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   95    102   
    CREATEACCESSTOKENOUTPUT_SCHEMA_ID,
   96    103   
    ::aws_smithy_schema::ShapeType::Structure,
   97    104   
    &[
   98    105   
        &CREATEACCESSTOKENOUTPUT_MEMBER_SECRET,
   99    106   
        &CREATEACCESSTOKENOUTPUT_MEMBER_NAME,
  100    107   
        &CREATEACCESSTOKENOUTPUT_MEMBER_EXPIRES_TIME,
  101    108   
        &CREATEACCESSTOKENOUTPUT_MEMBER_ACCESS_TOKEN_ID,
         109  +
        &CREATEACCESSTOKENOUTPUT_MEMBER__REQUEST_ID,
  102    110   
    ],
  103    111   
);
  104    112   
impl CreateAccessTokenOutput {
  105    113   
    /// The schema for this shape.
  106    114   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEACCESSTOKENOUTPUT_SCHEMA;
  107    115   
}
  108    116   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAccessTokenOutput {
  109    117   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  110    118   
    fn serialize_members(
  111    119   
        &self,
  112    120   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  113    121   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  114    122   
        {
  115    123   
            let val = &self.secret;
  116    124   
            ser.write_string(&CREATEACCESSTOKENOUTPUT_MEMBER_SECRET, val)?;
  117    125   
        }
  118    126   
        {
  119    127   
            let val = &self.name;
  120    128   
            ser.write_string(&CREATEACCESSTOKENOUTPUT_MEMBER_NAME, val)?;
  121    129   
        }
  122    130   
        {
  123    131   
            let val = &self.expires_time;
  124    132   
            ser.write_timestamp(&CREATEACCESSTOKENOUTPUT_MEMBER_EXPIRES_TIME, val)?;
  125    133   
        }
  126    134   
        {
  127    135   
            let val = &self.access_token_id;
  128    136   
            ser.write_string(&CREATEACCESSTOKENOUTPUT_MEMBER_ACCESS_TOKEN_ID, val)?;
  129    137   
        }
  130    138   
        Ok(())
  131    139   
    }
  132    140   
}
  133    141   
impl CreateAccessTokenOutput {
  134    142   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  135         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  136         -
        deserializer: &mut D,
         143  +
    pub fn deserialize(
         144  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  137    145   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  138    146   
        #[allow(unused_variables, unused_mut)]
  139    147   
        let mut builder = Self::builder();
  140    148   
        #[allow(
  141    149   
            unused_variables,
  142    150   
            unreachable_code,
  143    151   
            clippy::single_match,
  144    152   
            clippy::match_single_binding,
  145    153   
            clippy::diverging_sub_expression
  146    154   
        )]
  147         -
        deserializer.read_struct(&CREATEACCESSTOKENOUTPUT_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&CREATEACCESSTOKENOUTPUT_SCHEMA, &mut |member, deser| {
         156  +
            match member.member_index() {
         157  +
                Some(0) => {
         158  +
                    builder.secret = Some(deser.read_string(member)?);
         159  +
                }
         160  +
                Some(1) => {
         161  +
                    builder.name = Some(deser.read_string(member)?);
         162  +
                }
         163  +
                Some(2) => {
         164  +
                    builder.expires_time = Some(deser.read_timestamp(member)?);
         165  +
                }
         166  +
                Some(3) => {
         167  +
                    builder.access_token_id = Some(deser.read_string(member)?);
         168  +
                }
         169  +
                Some(4) => {
         170  +
                    builder._request_id = Some(deser.read_string(member)?);
         171  +
                }
         172  +
                _ => {}
         173  +
            }
         174  +
            Ok(())
         175  +
        })?;
         176  +
        builder.secret = builder.secret.or(Some(String::new()));
         177  +
        builder.name = builder.name.or(Some(String::new()));
         178  +
        builder.expires_time = builder.expires_time.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         179  +
        builder.access_token_id = builder.access_token_id.or(Some(String::new()));
         180  +
        builder
         181  +
            .build()
         182  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         183  +
    }
         184  +
}
         185  +
impl CreateAccessTokenOutput {
         186  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         187  +
    /// Header-bound members are read directly from headers, avoiding runtime
         188  +
    /// member iteration overhead. Body members are read via the deserializer.
         189  +
    pub fn deserialize_with_response(
         190  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         191  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         192  +
        _status: u16,
         193  +
        _body: &[u8],
         194  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         195  +
        #[allow(unused_variables, unused_mut)]
         196  +
        let mut builder = Self::builder();
         197  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         198  +
            builder._request_id = Some(val.to_string());
         199  +
        }
         200  +
        #[allow(
         201  +
            unused_variables,
         202  +
            unreachable_code,
         203  +
            clippy::single_match,
         204  +
            clippy::match_single_binding,
         205  +
            clippy::diverging_sub_expression
         206  +
        )]
         207  +
        deserializer.read_struct(&CREATEACCESSTOKENOUTPUT_SCHEMA, &mut |member, deser| {
  148    208   
            match member.member_index() {
  149    209   
                Some(0) => {
  150    210   
                    builder.secret = Some(deser.read_string(member)?);
  151    211   
                }
  152    212   
                Some(1) => {
  153    213   
                    builder.name = Some(deser.read_string(member)?);
  154    214   
                }
  155    215   
                Some(2) => {
  156    216   
                    builder.expires_time = Some(deser.read_timestamp(member)?);
  157    217   
                }

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_dev_environment.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 `CreateDevEnvironment`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateDevEnvironment;
    6      6   
impl CreateDevEnvironment {
    7      7   
    /// Creates a new `CreateDevEnvironment`
    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::create_dev_environment::CreateDevEnvironmentInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_dev_environment::CreateDevEnvironmentOutput::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::create_dev_environment::CreateDevEnvironmentInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::create_dev_environment::CreateDevEnvironmentOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::create_dev_environment::CreateDevEnvironmentError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -108,112 +260,413 @@
  128    132   
                crate::operation::create_dev_environment::CreateDevEnvironmentError,
  129    133   
            >::new());
  130    134   
  131    135   
        ::std::borrow::Cow::Owned(rcb)
  132    136   
    }
  133    137   
}
  134    138   
  135    139   
#[derive(Debug)]
  136    140   
struct CreateDevEnvironmentResponseDeserializer;
  137    141   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateDevEnvironmentResponseDeserializer {
  138         -
    fn deserialize_nonstreaming(
         142  +
    fn deserialize_nonstreaming_with_config(
  139    143   
        &self,
  140    144   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         145  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  141    146   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  142    147   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  143         -
        let headers = response.headers();
  144         -
        let body = response.body().bytes().expect("body loaded");
  145    148   
        #[allow(unused_mut)]
  146    149   
        let mut force_error = false;
  147    150   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  148         -
        let parse_result = if !success && status != 201 || force_error {
  149         -
            crate::protocol_serde::shape_create_dev_environment::de_create_dev_environment_http_error(status, headers, body)
         151  +
        if !success && status != 201 || force_error {
         152  +
            let headers = response.headers();
         153  +
            let body = response.body().bytes().expect("body loaded");
         154  +
            #[allow(unused_mut)]
         155  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         156  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         157  +
            })?;
         158  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         159  +
            let generic = generic_builder.build();
         160  +
            let error_code = match generic.code() {
         161  +
                ::std::option::Option::Some(code) => code,
         162  +
                ::std::option::Option::None => {
         163  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         164  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         165  +
                            crate::operation::create_dev_environment::CreateDevEnvironmentError::unhandled(generic),
         166  +
                        ),
         167  +
                    ))
         168  +
                }
         169  +
            };
         170  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         171  +
            let protocol = _cfg
         172  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         173  +
                .expect("a SharedClientProtocol is required");
         174  +
            let err = match error_code {
         175  +
                "AccessDeniedException" => crate::operation::create_dev_environment::CreateDevEnvironmentError::AccessDeniedException({
         176  +
                    let mut tmp = match protocol
         177  +
                        .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
         178  +
                        .and_then(|mut deser| {
         179  +
                            crate::types::error::AccessDeniedException::deserialize_with_response(
         180  +
                                &mut *deser,
         181  +
                                response.headers(),
         182  +
                                response.status().into(),
         183  +
                                body,
         184  +
                            )
         185  +
                        }) {
         186  +
                        ::std::result::Result::Ok(val) => val,
         187  +
                        ::std::result::Result::Err(e) => {
         188  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         189  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         190  +
                            ))
         191  +
                        }
         192  +
                    };
         193  +
                    tmp.meta = generic;
         194  +
                    tmp
         195  +
                }),
         196  +
                "ConflictException" => crate::operation::create_dev_environment::CreateDevEnvironmentError::ConflictException({
         197  +
                    let mut tmp = match protocol
         198  +
                        .deserialize_response(response, crate::types::error::ConflictException::SCHEMA, _cfg)
         199  +
                        .and_then(|mut deser| {
         200  +
                            crate::types::error::ConflictException::deserialize_with_response(
         201  +
                                &mut *deser,
         202  +
                                response.headers(),
         203  +
                                response.status().into(),
         204  +
                                body,
         205  +
                            )
         206  +
                        }) {
         207  +
                        ::std::result::Result::Ok(val) => val,
         208  +
                        ::std::result::Result::Err(e) => {
         209  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         210  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         211  +
                            ))
         212  +
                        }
         213  +
                    };
         214  +
                    tmp.meta = generic;
         215  +
                    tmp
         216  +
                }),
         217  +
                "ResourceNotFoundException" => crate::operation::create_dev_environment::CreateDevEnvironmentError::ResourceNotFoundException({
         218  +
                    let mut tmp = match protocol
         219  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         220  +
                        .and_then(|mut deser| {
         221  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         222  +
                                &mut *deser,
         223  +
                                response.headers(),
         224  +
                                response.status().into(),
         225  +
                                body,
         226  +
                            )
         227  +
                        }) {
         228  +
                        ::std::result::Result::Ok(val) => val,
         229  +
                        ::std::result::Result::Err(e) => {
         230  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         231  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         232  +
                            ))
         233  +
                        }
         234  +
                    };
         235  +
                    tmp.meta = generic;
         236  +
                    tmp
         237  +
                }),
         238  +
                "ServiceQuotaExceededException" => {
         239  +
                    crate::operation::create_dev_environment::CreateDevEnvironmentError::ServiceQuotaExceededException({
         240  +
                        let mut tmp = match protocol
         241  +
                            .deserialize_response(response, crate::types::error::ServiceQuotaExceededException::SCHEMA, _cfg)
         242  +
                            .and_then(|mut deser| {
         243  +
                                crate::types::error::ServiceQuotaExceededException::deserialize_with_response(
         244  +
                                    &mut *deser,
         245  +
                                    response.headers(),
         246  +
                                    response.status().into(),
         247  +
                                    body,
         248  +
                                )
         249  +
                            }) {
         250  +
                            ::std::result::Result::Ok(val) => val,
         251  +
                            ::std::result::Result::Err(e) => {
         252  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         253  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         254  +
                                ))
         255  +
                            }
         256  +
                        };
         257  +
                        tmp.meta = generic;
         258  +
                        tmp
         259  +
                    })
         260  +
                }
         261  +
                "ThrottlingException" => crate::operation::create_dev_environment::CreateDevEnvironmentError::ThrottlingException({
         262  +
                    let mut tmp = match protocol
         263  +
                        .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
         264  +
                        .and_then(|mut deser| {
         265  +
                            crate::types::error::ThrottlingException::deserialize_with_response(
         266  +
                                &mut *deser,
         267  +
                                response.headers(),
         268  +
                                response.status().into(),
         269  +
                                body,
         270  +
                            )
         271  +
                        }) {
         272  +
                        ::std::result::Result::Ok(val) => val,
         273  +
                        ::std::result::Result::Err(e) => {
         274  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         275  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         276  +
                            ))
         277  +
                        }
         278  +
                    };
         279  +
                    tmp.meta = generic;
         280  +
                    tmp
         281  +
                }),
         282  +
                "ValidationException" => crate::operation::create_dev_environment::CreateDevEnvironmentError::ValidationException({
         283  +
                    let mut tmp = match protocol
         284  +
                        .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
         285  +
                        .and_then(|mut deser| {
         286  +
                            crate::types::error::ValidationException::deserialize_with_response(
         287  +
                                &mut *deser,
         288  +
                                response.headers(),
         289  +
                                response.status().into(),
         290  +
                                body,
         291  +
                            )
         292  +
                        }) {
         293  +
                        ::std::result::Result::Ok(val) => val,
         294  +
                        ::std::result::Result::Err(e) => {
         295  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         296  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         297  +
                            ))
         298  +
                        }
         299  +
                    };
         300  +
                    tmp.meta = generic;
         301  +
                    tmp
         302  +
                }),
         303  +
                _ => crate::operation::create_dev_environment::CreateDevEnvironmentError::generic(generic),
         304  +
            };
         305  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         306  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         307  +
            ))
  150    308   
        } else {
  151         -
            crate::protocol_serde::shape_create_dev_environment::de_create_dev_environment_http_response(status, headers, body)
  152         -
        };
  153         -
        crate::protocol_serde::type_erase_result(parse_result)
         309  +
            let protocol = _cfg
         310  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         311  +
                .expect("a SharedClientProtocol is required");
         312  +
            let mut deser = protocol
         313  +
                .deserialize_response(response, CreateDevEnvironment::OUTPUT_SCHEMA, _cfg)
         314  +
                .map_err(|e| {
         315  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         316  +
                })?;
         317  +
            let body = response.body().bytes().expect("body loaded");
         318  +
            let output = crate::operation::create_dev_environment::CreateDevEnvironmentOutput::deserialize_with_response(
         319  +
                &mut *deser,
         320  +
                response.headers(),
         321  +
                response.status().into(),
         322  +
                body,
         323  +
            )
         324  +
            .map_err(|e| {
         325  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         326  +
            })?;
         327  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         328  +
        }
  154    329   
    }
  155    330   
}
  156    331   
#[derive(Debug)]
  157    332   
struct CreateDevEnvironmentRequestSerializer;
  158    333   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateDevEnvironmentRequestSerializer {
  159    334   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  160    335   
    fn serialize_input(
  161    336   
        &self,
  162    337   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  163    338   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  164    339   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  165    340   
        let input = input
  166    341   
            .downcast::<crate::operation::create_dev_environment::CreateDevEnvironmentInput>()
  167    342   
            .expect("correct type");
  168         -
        let _header_serialization_settings = _cfg
  169         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  170         -
            .cloned()
  171         -
            .unwrap_or_default();
  172         -
        let mut request_builder = {
  173         -
            #[allow(clippy::uninlined_format_args)]
  174         -
            fn uri_base(
  175         -
                _input: &crate::operation::create_dev_environment::CreateDevEnvironmentInput,
  176         -
                output: &mut ::std::string::String,
  177         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  178         -
                use ::std::fmt::Write as _;
  179         -
                let input_1 = &_input.space_name;
  180         -
                let input_1 = input_1
  181         -
                    .as_ref()
  182         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("space_name", "cannot be empty or unset"))?;
  183         -
                let space_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  184         -
                if space_name.is_empty() {
  185         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  186         -
                        "space_name",
  187         -
                        "cannot be empty or unset",
  188         -
                    ));
         343  +
        let protocol = _cfg
         344  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         345  +
            .expect("a SharedClientProtocol is required");
         346  +
        if protocol.supports_http_bindings() {
         347  +
            let mut request = protocol
         348  +
                .serialize_body(&input, CreateDevEnvironment::INPUT_SCHEMA, "", _cfg)
         349  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         350  +
            {
         351  +
                let mut uri = "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments".to_string();
         352  +
                let mut query_params: Vec<(String, String)> = Vec::new();
         353  +
                if let Some(ref val) = input.space_name {
         354  +
                    uri = uri.replace("{spaceName}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
  189    355   
                }
  190         -
                let input_2 = &_input.project_name;
  191         -
                let input_2 = input_2
  192         -
                    .as_ref()
  193         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("project_name", "cannot be empty or unset"))?;
  194         -
                let project_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
  195         -
                if project_name.is_empty() {
  196         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  197         -
                        "project_name",
  198         -
                        "cannot be empty or unset",
  199         -
                    ));
         356  +
                if let Some(ref val) = input.project_name {
         357  +
                    uri = uri.replace("{projectName}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
  200    358   
                }
  201         -
                ::std::write!(
  202         -
                    output,
  203         -
                    "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments",
  204         -
                    spaceName = space_name,
  205         -
                    projectName = project_name
  206         -
                )
  207         -
                .expect("formatting should succeed");
  208         -
                ::std::result::Result::Ok(())
  209         -
            }
  210         -
            #[allow(clippy::unnecessary_wraps)]
  211         -
            fn update_http_builder(
  212         -
                input: &crate::operation::create_dev_environment::CreateDevEnvironmentInput,
  213         -
                builder: ::http_1x::request::Builder,
  214         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  215         -
                let mut uri = ::std::string::String::new();
  216         -
                uri_base(input, &mut uri)?;
  217         -
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
         359  +
                if !query_params.is_empty() {
         360  +
                    uri.push(if uri.contains('?') { '&' } else { '?' });
         361  +
                    let pairs: Vec<String> = query_params
         362  +
                        .iter()
         363  +
                        .map(|(k, v)| {
         364  +
                            format!(
         365  +
                                "{}={}",
         366  +
                                ::aws_smithy_schema::http_protocol::percent_encode(k),
         367  +
                                ::aws_smithy_schema::http_protocol::percent_encode(v)
         368  +
                            )
         369  +
                        })
         370  +
                        .collect();
         371  +
                    uri.push_str(&pairs.join("&"));
         372  +
                }
         373  +
                request.set_uri(uri.as_str()).expect("valid URI");
  218    374   
            }
  219         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  220         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  221         -
            builder
  222         -
        };
  223         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_dev_environment::ser_create_dev_environment_input(
  224         -
            &input,
  225         -
        )?);
  226         -
        if let Some(content_length) = body.content_length() {
  227         -
            let content_length = content_length.to_string();
  228         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         375  +
         376  +
            return ::std::result::Result::Ok(request);
         377  +
        } else {
         378  +
            let mut request = protocol
         379  +
                .serialize_request(&input, CreateDevEnvironment::INPUT_SCHEMA, "", _cfg)
         380  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         381  +
         382  +
            return ::std::result::Result::Ok(request);
  229    383   
        }
  230         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  231    384   
    }
  232    385   
}
  233    386   
#[derive(Debug)]
  234    387   
struct CreateDevEnvironmentEndpointParamsInterceptor;
  235    388   
  236    389   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateDevEnvironmentEndpointParamsInterceptor {
  237    390   
    fn name(&self) -> &'static str {
  238    391   
        "CreateDevEnvironmentEndpointParamsInterceptor"
  239    392   
    }
  240    393

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_dev_environment/_create_dev_environment_input.rs

@@ -63,63 +233,238 @@
   83     83   
    "com.amazonaws.codecatalyst.synthetic",
   84     84   
    "CreateDevEnvironmentInput",
   85     85   
);
   86     86   
static CREATEDEVENVIRONMENTINPUT_MEMBER_SPACE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$spaceName",
   89     89   
        "com.amazonaws.codecatalyst.synthetic",
   90     90   
        "CreateDevEnvironmentInput",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "space_name",
          93  +
    "spaceName",
   94     94   
    0,
   95     95   
)
   96     96   
.with_http_label();
   97     97   
static CREATEDEVENVIRONMENTINPUT_MEMBER_PROJECT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$projectName",
  100    100   
        "com.amazonaws.codecatalyst.synthetic",
  101    101   
        "CreateDevEnvironmentInput",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "project_name",
         104  +
    "projectName",
  105    105   
    1,
  106    106   
)
  107    107   
.with_http_label();
  108    108   
static CREATEDEVENVIRONMENTINPUT_MEMBER_REPOSITORIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$repositories",
  111    111   
        "com.amazonaws.codecatalyst.synthetic",
  112    112   
        "CreateDevEnvironmentInput",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::List,
  115    115   
    "repositories",
  116    116   
    2,
  117    117   
);
  118    118   
static CREATEDEVENVIRONMENTINPUT_MEMBER_CLIENT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$clientToken",
  121    121   
        "com.amazonaws.codecatalyst.synthetic",
  122    122   
        "CreateDevEnvironmentInput",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "client_token",
         125  +
    "clientToken",
  126    126   
    3,
  127    127   
);
  128    128   
static CREATEDEVENVIRONMENTINPUT_MEMBER_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$alias",
  131    131   
        "com.amazonaws.codecatalyst.synthetic",
  132    132   
        "CreateDevEnvironmentInput",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::String,
  135    135   
    "alias",
  136    136   
    4,
  137    137   
);
  138    138   
static CREATEDEVENVIRONMENTINPUT_MEMBER_IDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$ides",
  141    141   
        "com.amazonaws.codecatalyst.synthetic",
  142    142   
        "CreateDevEnvironmentInput",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::List,
  145    145   
    "ides",
  146    146   
    5,
  147    147   
);
  148    148   
static CREATEDEVENVIRONMENTINPUT_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$instanceType",
  151    151   
        "com.amazonaws.codecatalyst.synthetic",
  152    152   
        "CreateDevEnvironmentInput",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "instance_type",
         155  +
    "instanceType",
  156    156   
    6,
  157    157   
);
  158    158   
static CREATEDEVENVIRONMENTINPUT_MEMBER_INACTIVITY_TIMEOUT_MINUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$inactivityTimeoutMinutes",
  161    161   
        "com.amazonaws.codecatalyst.synthetic",
  162    162   
        "CreateDevEnvironmentInput",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::Integer,
  165         -
    "inactivity_timeout_minutes",
         165  +
    "inactivityTimeoutMinutes",
  166    166   
    7,
  167    167   
);
  168    168   
static CREATEDEVENVIRONMENTINPUT_MEMBER_PERSISTENT_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$persistentStorage",
  171    171   
        "com.amazonaws.codecatalyst.synthetic",
  172    172   
        "CreateDevEnvironmentInput",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::Structure,
  175         -
    "persistent_storage",
         175  +
    "persistentStorage",
  176    176   
    8,
  177    177   
);
  178    178   
static CREATEDEVENVIRONMENTINPUT_MEMBER_VPC_CONNECTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentInput$vpcConnectionName",
  181    181   
        "com.amazonaws.codecatalyst.synthetic",
  182    182   
        "CreateDevEnvironmentInput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "vpc_connection_name",
         185  +
    "vpcConnectionName",
  186    186   
    9,
  187    187   
);
  188    188   
static CREATEDEVENVIRONMENTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  189    189   
    CREATEDEVENVIRONMENTINPUT_SCHEMA_ID,
  190    190   
    ::aws_smithy_schema::ShapeType::Structure,
  191    191   
    &[
  192    192   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_SPACE_NAME,
  193    193   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_PROJECT_NAME,
  194    194   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_REPOSITORIES,
  195    195   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_CLIENT_TOKEN,
  196    196   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_ALIAS,
  197    197   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_IDES,
  198    198   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_INSTANCE_TYPE,
  199    199   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_INACTIVITY_TIMEOUT_MINUTES,
  200    200   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_PERSISTENT_STORAGE,
  201    201   
        &CREATEDEVENVIRONMENTINPUT_MEMBER_VPC_CONNECTION_NAME,
  202    202   
    ],
  203         -
);
         203  +
)
         204  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         205  +
    "PUT",
         206  +
    "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments",
         207  +
    Some(201),
         208  +
));
  204    209   
impl CreateDevEnvironmentInput {
  205    210   
    /// The schema for this shape.
  206    211   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEDEVENVIRONMENTINPUT_SCHEMA;
  207    212   
}
  208    213   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateDevEnvironmentInput {
  209    214   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  210    215   
    fn serialize_members(
  211    216   
        &self,
  212    217   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  213    218   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -235,240 +367,379 @@
  255    260   
            ser.write_struct(&CREATEDEVENVIRONMENTINPUT_MEMBER_PERSISTENT_STORAGE, val)?;
  256    261   
        }
  257    262   
        if let Some(ref val) = self.vpc_connection_name {
  258    263   
            ser.write_string(&CREATEDEVENVIRONMENTINPUT_MEMBER_VPC_CONNECTION_NAME, val)?;
  259    264   
        }
  260    265   
        Ok(())
  261    266   
    }
  262    267   
}
  263    268   
impl CreateDevEnvironmentInput {
  264    269   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  265         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  266         -
        deserializer: &mut D,
         270  +
    pub fn deserialize(
         271  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  267    272   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  268    273   
        #[allow(unused_variables, unused_mut)]
  269    274   
        let mut builder = Self::builder();
  270    275   
        #[allow(
  271    276   
            unused_variables,
  272    277   
            unreachable_code,
  273    278   
            clippy::single_match,
  274    279   
            clippy::match_single_binding,
  275    280   
            clippy::diverging_sub_expression
  276    281   
        )]
  277         -
        deserializer.read_struct(&CREATEDEVENVIRONMENTINPUT_SCHEMA, (), |_, member, deser| {
         282  +
        deserializer.read_struct(&CREATEDEVENVIRONMENTINPUT_SCHEMA, &mut |member, deser| {
  278    283   
            match member.member_index() {
  279    284   
                Some(0) => {
  280    285   
                    builder.space_name = Some(deser.read_string(member)?);
  281    286   
                }
  282    287   
                Some(1) => {
  283    288   
                    builder.project_name = Some(deser.read_string(member)?);
  284    289   
                }
  285    290   
                Some(2) => {
  286    291   
                    builder.repositories = Some({
  287         -
                        let container = if let Some(cap) = deser.container_size() {
  288         -
                            Vec::with_capacity(cap)
  289         -
                        } else {
  290         -
                            Vec::new()
  291         -
                        };
  292         -
                        deser.read_list(member, container, |mut list, deser| {
  293         -
                            list.push(crate::types::RepositoryInput::deserialize(deser)?);
  294         -
                            Ok(list)
  295         -
                        })?
         292  +
                        let mut container = Vec::new();
         293  +
                        deser.read_list(member, &mut |deser| {
         294  +
                            container.push(crate::types::RepositoryInput::deserialize(deser)?);
         295  +
                            Ok(())
         296  +
                        })?;
         297  +
                        container
  296    298   
                    });
  297    299   
                }
  298    300   
                Some(3) => {
  299    301   
                    builder.client_token = Some(deser.read_string(member)?);
  300    302   
                }
  301    303   
                Some(4) => {
  302    304   
                    builder.alias = Some(deser.read_string(member)?);
  303    305   
                }
  304    306   
                Some(5) => {
  305    307   
                    builder.ides = Some({
  306         -
                        let container = if let Some(cap) = deser.container_size() {
  307         -
                            Vec::with_capacity(cap)
  308         -
                        } else {
  309         -
                            Vec::new()
  310         -
                        };
  311         -
                        deser.read_list(member, container, |mut list, deser| {
  312         -
                            list.push(crate::types::IdeConfiguration::deserialize(deser)?);
  313         -
                            Ok(list)
  314         -
                        })?
         308  +
                        let mut container = Vec::new();
         309  +
                        deser.read_list(member, &mut |deser| {
         310  +
                            container.push(crate::types::IdeConfiguration::deserialize(deser)?);
         311  +
                            Ok(())
         312  +
                        })?;
         313  +
                        container
  315    314   
                    });
  316    315   
                }
  317    316   
                Some(6) => {
  318    317   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  319    318   
                }
  320    319   
                Some(7) => {
  321    320   
                    builder.inactivity_timeout_minutes = Some(deser.read_integer(member)?);
  322    321   
                }
  323    322   
                Some(8) => {
  324    323   
                    builder.persistent_storage = Some(crate::types::PersistentStorageConfiguration::deserialize(deser)?);
  325    324   
                }
  326    325   
                Some(9) => {
  327    326   
                    builder.vpc_connection_name = Some(deser.read_string(member)?);
  328    327   
                }
  329    328   
                _ => {}
  330    329   
            }
  331    330   
            Ok(())
  332    331   
        })?;
         332  +
        builder.space_name = builder.space_name.or(Some(String::new()));
         333  +
        builder.project_name = builder.project_name.or(Some(String::new()));
  333    334   
        builder
  334    335   
            .build()
  335    336   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  336    337   
    }
  337    338   
}
         339  +
impl CreateDevEnvironmentInput {
         340  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         341  +
    pub fn deserialize_with_response(
         342  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         343  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         344  +
        _status: u16,
         345  +
        _body: &[u8],
         346  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         347  +
        Self::deserialize(deserializer)
         348  +
    }
         349  +
}
  338    350   
impl CreateDevEnvironmentInput {
  339    351   
    /// Creates a new builder-style object to manufacture [`CreateDevEnvironmentInput`](crate::operation::create_dev_environment::CreateDevEnvironmentInput).
  340    352   
    pub fn builder() -> crate::operation::create_dev_environment::builders::CreateDevEnvironmentInputBuilder {
  341    353   
        crate::operation::create_dev_environment::builders::CreateDevEnvironmentInputBuilder::default()
  342    354   
    }
  343    355   
}
  344    356   
  345    357   
/// A builder for [`CreateDevEnvironmentInput`](crate::operation::create_dev_environment::CreateDevEnvironmentInput).
  346    358   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  347    359   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_dev_environment/_create_dev_environment_output.rs

@@ -19,19 +164,223 @@
   39     39   
    "com.amazonaws.codecatalyst.synthetic",
   40     40   
    "CreateDevEnvironmentOutput",
   41     41   
);
   42     42   
static CREATEDEVENVIRONMENTOUTPUT_MEMBER_SPACE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentOutput$spaceName",
   45     45   
        "com.amazonaws.codecatalyst.synthetic",
   46     46   
        "CreateDevEnvironmentOutput",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "space_name",
          49  +
    "spaceName",
   50     50   
    0,
   51     51   
);
   52     52   
static CREATEDEVENVIRONMENTOUTPUT_MEMBER_PROJECT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentOutput$projectName",
   55     55   
        "com.amazonaws.codecatalyst.synthetic",
   56     56   
        "CreateDevEnvironmentOutput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "project_name",
          59  +
    "projectName",
   60     60   
    1,
   61     61   
);
   62     62   
static CREATEDEVENVIRONMENTOUTPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentOutput$id",
   65     65   
        "com.amazonaws.codecatalyst.synthetic",
   66     66   
        "CreateDevEnvironmentOutput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69     69   
    "id",
   70     70   
    2,
   71     71   
);
   72     72   
static CREATEDEVENVIRONMENTOUTPUT_MEMBER_VPC_CONNECTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.codecatalyst.synthetic#CreateDevEnvironmentOutput$vpcConnectionName",
   75     75   
        "com.amazonaws.codecatalyst.synthetic",
   76     76   
        "CreateDevEnvironmentOutput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "vpc_connection_name",
          79  +
    "vpcConnectionName",
   80     80   
    3,
   81     81   
);
          82  +
static CREATEDEVENVIRONMENTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          83  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          84  +
    ::aws_smithy_schema::ShapeType::String,
          85  +
    "request_id",
          86  +
    4,
          87  +
)
          88  +
.with_http_header("x-amzn-requestid");
   82     89   
static CREATEDEVENVIRONMENTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   83     90   
    CREATEDEVENVIRONMENTOUTPUT_SCHEMA_ID,
   84     91   
    ::aws_smithy_schema::ShapeType::Structure,
   85     92   
    &[
   86     93   
        &CREATEDEVENVIRONMENTOUTPUT_MEMBER_SPACE_NAME,
   87     94   
        &CREATEDEVENVIRONMENTOUTPUT_MEMBER_PROJECT_NAME,
   88     95   
        &CREATEDEVENVIRONMENTOUTPUT_MEMBER_ID,
   89     96   
        &CREATEDEVENVIRONMENTOUTPUT_MEMBER_VPC_CONNECTION_NAME,
          97  +
        &CREATEDEVENVIRONMENTOUTPUT_MEMBER__REQUEST_ID,
   90     98   
    ],
   91     99   
);
   92    100   
impl CreateDevEnvironmentOutput {
   93    101   
    /// The schema for this shape.
   94    102   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEDEVENVIRONMENTOUTPUT_SCHEMA;
   95    103   
}
   96    104   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateDevEnvironmentOutput {
   97    105   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   98    106   
    fn serialize_members(
   99    107   
        &self,
  100    108   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  101    109   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  102    110   
        {
  103    111   
            let val = &self.space_name;
  104    112   
            ser.write_string(&CREATEDEVENVIRONMENTOUTPUT_MEMBER_SPACE_NAME, val)?;
  105    113   
        }
  106    114   
        {
  107    115   
            let val = &self.project_name;
  108    116   
            ser.write_string(&CREATEDEVENVIRONMENTOUTPUT_MEMBER_PROJECT_NAME, val)?;
  109    117   
        }
  110    118   
        {
  111    119   
            let val = &self.id;
  112    120   
            ser.write_string(&CREATEDEVENVIRONMENTOUTPUT_MEMBER_ID, val)?;
  113    121   
        }
  114    122   
        if let Some(ref val) = self.vpc_connection_name {
  115    123   
            ser.write_string(&CREATEDEVENVIRONMENTOUTPUT_MEMBER_VPC_CONNECTION_NAME, val)?;
  116    124   
        }
  117    125   
        Ok(())
  118    126   
    }
  119    127   
}
  120    128   
impl CreateDevEnvironmentOutput {
  121    129   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  122         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  123         -
        deserializer: &mut D,
         130  +
    pub fn deserialize(
         131  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         132  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         133  +
        #[allow(unused_variables, unused_mut)]
         134  +
        let mut builder = Self::builder();
         135  +
        #[allow(
         136  +
            unused_variables,
         137  +
            unreachable_code,
         138  +
            clippy::single_match,
         139  +
            clippy::match_single_binding,
         140  +
            clippy::diverging_sub_expression
         141  +
        )]
         142  +
        deserializer.read_struct(&CREATEDEVENVIRONMENTOUTPUT_SCHEMA, &mut |member, deser| {
         143  +
            match member.member_index() {
         144  +
                Some(0) => {
         145  +
                    builder.space_name = Some(deser.read_string(member)?);
         146  +
                }
         147  +
                Some(1) => {
         148  +
                    builder.project_name = Some(deser.read_string(member)?);
         149  +
                }
         150  +
                Some(2) => {
         151  +
                    builder.id = Some(deser.read_string(member)?);
         152  +
                }
         153  +
                Some(3) => {
         154  +
                    builder.vpc_connection_name = Some(deser.read_string(member)?);
         155  +
                }
         156  +
                Some(4) => {
         157  +
                    builder._request_id = Some(deser.read_string(member)?);
         158  +
                }
         159  +
                _ => {}
         160  +
            }
         161  +
            Ok(())
         162  +
        })?;
         163  +
        builder.space_name = builder.space_name.or(Some(String::new()));
         164  +
        builder.project_name = builder.project_name.or(Some(String::new()));
         165  +
        builder.id = builder.id.or(Some(String::new()));
         166  +
        builder
         167  +
            .build()
         168  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         169  +
    }
         170  +
}
         171  +
impl CreateDevEnvironmentOutput {
         172  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         173  +
    /// Header-bound members are read directly from headers, avoiding runtime
         174  +
    /// member iteration overhead. Body members are read via the deserializer.
         175  +
    pub fn deserialize_with_response(
         176  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         177  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         178  +
        _status: u16,
         179  +
        _body: &[u8],
  124    180   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  125    181   
        #[allow(unused_variables, unused_mut)]
  126    182   
        let mut builder = Self::builder();
         183  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         184  +
            builder._request_id = Some(val.to_string());
         185  +
        }
  127    186   
        #[allow(
  128    187   
            unused_variables,
  129    188   
            unreachable_code,
  130    189   
            clippy::single_match,
  131    190   
            clippy::match_single_binding,
  132    191   
            clippy::diverging_sub_expression
  133    192   
        )]
  134         -
        deserializer.read_struct(&CREATEDEVENVIRONMENTOUTPUT_SCHEMA, (), |_, member, deser| {
         193  +
        deserializer.read_struct(&CREATEDEVENVIRONMENTOUTPUT_SCHEMA, &mut |member, deser| {
  135    194   
            match member.member_index() {
  136    195   
                Some(0) => {
  137    196   
                    builder.space_name = Some(deser.read_string(member)?);
  138    197   
                }
  139    198   
                Some(1) => {
  140    199   
                    builder.project_name = Some(deser.read_string(member)?);
  141    200   
                }
  142    201   
                Some(2) => {
  143    202   
                    builder.id = Some(deser.read_string(member)?);
  144    203   
                }