Server Test Python

rev. 7254d43655ed63111c94f599437f2b0d3f55446e

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/lib.rs

@@ -146,146 +249,244 @@

 //! ) -> Output {
 //!     todo!()
 //! }
 //! ```
 //!
 //! See the [`operation module`](crate::operation) for information on precisely what constitutes a handler.
 //!
 //! ## Build
 //!
 //! You can convert [`RestJsonExtrasBuilder`] into [`RestJsonExtras`] using either [`RestJsonExtrasBuilder::build`] or [`RestJsonExtrasBuilder::build_unchecked`].
 //!
 //! [`RestJsonExtrasBuilder::build`] requires you to provide a handler for every single operation in your Smithy model. It will return an error if that is not the case.
 //!
 //! [`RestJsonExtrasBuilder::build_unchecked`], instead, does not require exhaustiveness. The server will automatically return 500 Internal Server Error to all requests for operations that do not have a registered handler.
 //! [`RestJsonExtrasBuilder::build_unchecked`] is particularly useful if you are deploying your Smithy service as a collection of Lambda functions, where each Lambda is only responsible for a subset of the operations in the Smithy service (or even a single one!).
 //!
 //! # Example
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;

 //! use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig};
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = RestJsonExtrasConfig::builder().build();
 //!    let app = RestJsonExtras::builder(config)
 //!        .case_insensitive_error_operation(case_insensitive_error_operation)
 //!        .empty_struct_with_content_on_wire_op(empty_struct_with_content_on_wire_op)
 //!        .enum_query(enum_query)
 //!        .escaped_string_values(escaped_string_values)
 //!        .http_query_params_only_operation(http_query_params_only_operation)
 //!        .map_with_enum_key_op(map_with_enum_key_op)
 //!        .null_in_non_sparse(null_in_non_sparse)
 //!        .primitive_int_header(primitive_int_header)
 //!        .primitive_int_op(primitive_int_op)
 //!        .query_precedence(query_precedence)
 //!        .status_response(status_response)
 //!        .string_payload(string_payload)
 //!        .build()
 //!        .expect("failed to build an instance of RestJsonExtras");
 //!
 //!    let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!        .expect("unable to parse the server bind address and port");
 //!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());
 //!    # let server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use rest_json_extras::{input, output, error};
 //!
 //! async fn case_insensitive_error_operation(input: input::CaseInsensitiveErrorOperationInput) -> Result<output::CaseInsensitiveErrorOperationOutput, error::CaseInsensitiveErrorOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn empty_struct_with_content_on_wire_op(input: input::EmptyStructWithContentOnWireOpInput) -> Result<output::EmptyStructWithContentOnWireOpOutput, error::EmptyStructWithContentOnWireOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn enum_query(input: input::EnumQueryInput) -> Result<output::EnumQueryOutput, error::EnumQueryError> {
 //!     todo!()
 //! }
 //!
 //! async fn escaped_string_values(input: input::EscapedStringValuesInput) -> Result<output::EscapedStringValuesOutput, error::EscapedStringValuesError> {
 //!     todo!()
 //! }
 //!
 //! async fn http_query_params_only_operation(input: input::HttpQueryParamsOnlyOperationInput) -> Result<output::HttpQueryParamsOnlyOperationOutput, error::HttpQueryParamsOnlyOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn map_with_enum_key_op(input: input::MapWithEnumKeyOpInput) -> Result<output::MapWithEnumKeyOpOutput, error::MapWithEnumKeyOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn null_in_non_sparse(input: input::NullInNonSparseInput) -> Result<output::NullInNonSparseOutput, error::NullInNonSparseError> {
 //!     todo!()
 //! }
 //!
 //! async fn primitive_int_header(input: input::PrimitiveIntHeaderInput) -> Result<output::PrimitiveIntHeaderOutput, error::PrimitiveIntHeaderError> {
 //!     todo!()

↧ Expand context

 //! }
 //!
 //! async fn primitive_int_op(input: input::PrimitiveIntOpInput) -> Result<output::PrimitiveIntOpOutput, error::PrimitiveIntOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn query_precedence(input: input::QueryPrecedenceInput) -> Result<output::QueryPrecedenceOutput, error::QueryPrecedenceError> {
 //!     todo!()
 //! }
 //!
 //! async fn status_response(input: input::StatusResponseInput) -> Result<output::StatusResponseOutput, error::StatusResponseError> {
 //!     todo!()
 //! }
 //!
 //! async fn string_payload(input: input::StringPayloadInput) -> Result<output::StringPayloadOutput, error::StringPayloadError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/mimes.rs

@@ -1,1 +14,14 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) static CONTENT_TYPE_APPLICATION_JSON: std::sync::LazyLock<::mime::Mime> =
 pub(crate) static CONTENT_TYPE_TEXT_PLAIN: std::sync::LazyLock<::mime::Mime> =
     std::sync::LazyLock::new(|| {
         "application/json"
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
-8
 pub(crate) static CONTENT_TYPE_TEXT_PLAIN: std::sync::LazyLock<::mime::Mime> =
 pub(crate) static CONTENT_TYPE_APPLICATION_JSON: std::sync::LazyLock<::mime::Mime> =
     std::sync::LazyLock::new(|| {
         "text/plain"
         "application/json"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/model.rs

@@ -1,1 +445,476 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct EmptyStruct {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl EmptyStruct {
     #[new]
     pub fn new() -> Self {
         Self {}
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<EmptyStruct> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<EmptyStruct>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStruct> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl EmptyStruct {
     /// Creates a new builder-style object to manufacture [`EmptyStruct`](crate::model::EmptyStruct).
     pub fn builder() -> crate::model::empty_struct::Builder {
         crate::model::empty_struct::Builder::default()
--
+    }
--
+}
--
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum SingleElementUnion {
     #[allow(missing_docs)] // documentation missing in model
     A(::std::string::String),
--
+}
 impl SingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_a(&self) -> ::std::result::Result<&::std::string::String, &Self> {
         if let SingleElementUnion::A(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
--
+        }
--
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     pub fn is_a(&self) -> bool {
         self.as_a().is_ok()
--
+    }
--
+}
 #[pyo3::pyclass(name = "SingleElementUnion")]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct PyUnionMarkerSingleElementUnion(pub SingleElementUnion);
 #[::pyo3::pymethods]
 impl PyUnionMarkerSingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     #[staticmethod]
     /// Creates a new union instance of [`A`](crate::model::SingleElementUnion::A)
     /// :param data str:
     /// :rtype SingleElementUnion:
     pub fn a(data: ::std::string::String) -> Self {
         Self(SingleElementUnion::A(data))
--
+    }
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// :rtype str:
     pub fn as_a(&self) -> ::pyo3::PyResult<::std::string::String> {
         match self.0.as_a() {
             Ok(variant) => Ok(variant.clone()),
             Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(
                 r"SingleElementUnion variant is not of type str",
             )),
--
+        }
--
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     /// :rtype bool:
     pub fn is_a(&self) -> bool {
         self.0.is_a()
--
+    }
--
+}
 impl ::pyo3::IntoPy<::pyo3::PyObject> for SingleElementUnion {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         PyUnionMarkerSingleElementUnion(self).into_py(py)
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for SingleElementUnion {
     fn extract(obj: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         let data: PyUnionMarkerSingleElementUnion = obj.extract()?;
         Ok(data.0)
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :param path str:
 /// :param message str:
 /// :rtype None:
 /// Describes one specific validation failure for an input member.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationExceptionField {
     #[pyo3(get, set)]
     /// :type str:
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub path: ::std::string::String,
     #[pyo3(get, set)]
     /// :type str:
     /// A detailed description of the validation failure.
     pub message: ::std::string::String,
--
+}
 impl ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub fn path(&self) -> &str {
         use std::ops::Deref;
         self.path.deref()
--
+    }
     /// A detailed description of the validation failure.
     pub fn message(&self) -> &str {
         use std::ops::Deref;
         self.message.deref()
--
+    }
--
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ValidationExceptionField {
     #[new]
     pub fn new(path: ::std::string::String, message: ::std::string::String) -> Self {
         Self { path, message }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ValidationExceptionField> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ValidationExceptionField>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ValidationExceptionField> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl ValidationExceptionField {
     /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     pub fn builder() -> crate::model::validation_exception_field::Builder {
         crate::model::validation_exception_field::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum EnumWithEscapedChars {
     /// this needs#tobe escaped
     HasQuotes,
 pub enum StringEnum {
     #[allow(missing_docs)] // documentation missing in model
     Normal,
     V,
-16
+}
 pub(crate) mod enum_with_escaped_chars_internal {
 pub(crate) mod string_enum_internal {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-20
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#EnumWithEscapedChars' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
-26
+            )
-27
+        }
-28
+    }
-29
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     &path
                 ),
                 path,
-42
+            }
-43
+        }
-44
+    }
-45
+}
 impl ::std::convert::TryFrom<&str> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "has\"quotes" => Ok(EnumWithEscapedChars::HasQuotes),
             "normal" => Ok(EnumWithEscapedChars::Normal),
             _ => Err(
                 crate::model::enum_with_escaped_chars_internal::ConstraintViolation(s.to_owned()),
             ),
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum_internal::ConstraintViolation(
                 s.to_owned(),
             )),
-56
+        }
-57
+    }
-58
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-64
+    {
         s.as_str().try_into()
-66
+    }
-67
+}
 impl std::str::FromStr for EnumWithEscapedChars {
     type Err = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum_internal::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-72
+    }
-73
+}
 impl EnumWithEscapedChars {
 impl StringEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             EnumWithEscapedChars::HasQuotes => "has\"quotes",
             EnumWithEscapedChars::Normal => "normal",
             StringEnum::V => "enumvalue",
-79
+        }
-80
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["has\"quotes", "normal"]
         &["enumvalue"]
-84
+    }
-85
+}
 impl ::std::convert::AsRef<str> for EnumWithEscapedChars {
 impl ::std::convert::AsRef<str> for StringEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-89
+    }
-90
+}
 #[::pyo3::pymethods]
 impl EnumWithEscapedChars {
 impl StringEnum {
     #[getter]
     pub fn name(&self) -> &str {
         match self {
             EnumWithEscapedChars::HasQuotes => "HasQuotes",
             EnumWithEscapedChars::Normal => "Normal",
             StringEnum::V => "V",
-97
+        }
-98
+    }
     #[getter]
     pub fn value(&self) -> &str {
         self.as_str()
-102
+    }
     fn __repr__(&self) -> String {
         self.as_str().to_owned()
-105
+    }
     fn __str__(&self) -> String {
         self.as_str().to_owned()
-108
+    }
-109
+}
 impl crate::constrained::Constrained for EnumWithEscapedChars {
 impl crate::constrained::Constrained for StringEnum {
     type Unconstrained = ::std::string::String;
-112
+}
-113
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>
     for crate::constrained::MaybeConstrained<crate::model::StringEnum>
-116
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-119
+    }
-120
+}
-121
 #[::pyo3::pyclass]
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum StringEnum {
 pub enum EnumWithEscapedChars {
     /// this needs#tobe escaped
     HasQuotes,
     #[allow(missing_docs)] // documentation missing in model
     V,
     Normal,
-138
+}
 pub(crate) mod string_enum_internal {
 pub(crate) mod enum_with_escaped_chars_internal {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-142
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
                 r#"Value provided for 'aws.protocoltests.restjson#EnumWithEscapedChars' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#
-148
+            )
-149
+        }
-150
+    }
-151
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#,
                     &path
                 ),
                 path,
-164
+            }
-165
+        }
-166
+    }
-167
+}
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<&str> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum_internal::ConstraintViolation(
                 s.to_owned(),
             )),
             "has\"quotes" => Ok(EnumWithEscapedChars::HasQuotes),
             "normal" => Ok(EnumWithEscapedChars::Normal),
             _ => Err(
                 crate::model::enum_with_escaped_chars_internal::ConstraintViolation(s.to_owned()),
             ),
-179
+        }
-180
+    }
-181
+}
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<::std::string::String> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-187
+    {
         s.as_str().try_into()
-189
+    }
-190
+}
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum_internal::ConstraintViolation;
 impl std::str::FromStr for EnumWithEscapedChars {
     type Err = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-195
+    }
-196
+}
 impl StringEnum {
 impl EnumWithEscapedChars {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             StringEnum::V => "enumvalue",
             EnumWithEscapedChars::HasQuotes => "has\"quotes",
             EnumWithEscapedChars::Normal => "normal",
-203
+        }
-204
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["enumvalue"]
         &["has\"quotes", "normal"]
-208
+    }
-209
+}
 impl ::std::convert::AsRef<str> for StringEnum {
 impl ::std::convert::AsRef<str> for EnumWithEscapedChars {
     fn as_ref(&self) -> &str {
         self.as_str()
-213
+    }
-214
+}
 #[::pyo3::pymethods]
 impl StringEnum {
 impl EnumWithEscapedChars {
     #[getter]
     pub fn name(&self) -> &str {
         match self {
             StringEnum::V => "V",
             EnumWithEscapedChars::HasQuotes => "HasQuotes",
             EnumWithEscapedChars::Normal => "Normal",
-222
+        }
-223
+    }
     #[getter]
     pub fn value(&self) -> &str {
         self.as_str()
-227
+    }
     fn __repr__(&self) -> String {
         self.as_str().to_owned()
-230
+    }
     fn __str__(&self) -> String {
         self.as_str().to_owned()
-233
+    }
-234
+}
 impl crate::constrained::Constrained for StringEnum {
 impl crate::constrained::Constrained for EnumWithEscapedChars {
     type Unconstrained = ::std::string::String;
-237
+}
-238
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::StringEnum>
     for crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>
-241
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-244
+    }
-245
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum SingleElementUnion {
     #[allow(missing_docs)] // documentation missing in model
     A(::std::string::String),
-+
+}
 impl SingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_a(&self) -> ::std::result::Result<&::std::string::String, &Self> {
         if let SingleElementUnion::A(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-+
+        }
-+
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     pub fn is_a(&self) -> bool {
         self.as_a().is_ok()
-+
+    }
-+
+}
 #[pyo3::pyclass(name = "SingleElementUnion")]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct PyUnionMarkerSingleElementUnion(pub SingleElementUnion);
 #[::pyo3::pymethods]
 impl PyUnionMarkerSingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     #[staticmethod]
     /// Creates a new union instance of [`A`](crate::model::SingleElementUnion::A)
     /// :param data str:
     /// :rtype SingleElementUnion:
     pub fn a(data: ::std::string::String) -> Self {
         Self(SingleElementUnion::A(data))
-+
+    }
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// :rtype str:
     pub fn as_a(&self) -> ::pyo3::PyResult<::std::string::String> {
         match self.0.as_a() {
             Ok(variant) => Ok(variant.clone()),
             Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(
                 r"SingleElementUnion variant is not of type str",
             )),
-+
+        }
-+
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     /// :rtype bool:
     pub fn is_a(&self) -> bool {
         self.0.is_a()
-+
+    }
-+
+}
 impl ::pyo3::IntoPy<::pyo3::PyObject> for SingleElementUnion {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         PyUnionMarkerSingleElementUnion(self).into_py(py)
-+
+    }
-+
+}
 impl<'source> ::pyo3::FromPyObject<'source> for SingleElementUnion {
     fn extract(obj: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         let data: PyUnionMarkerSingleElementUnion = obj.extract()?;
         Ok(data.0)
-+
+    }
-+
+}
-+
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct EmptyStruct {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl EmptyStruct {
     #[new]
     pub fn new() -> Self {
         Self {}
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<EmptyStruct> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<EmptyStruct>().map(Box::new)
-+
+    }
-+
+}
-+
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStruct> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-+
+    }
-+
+}
 impl EmptyStruct {
     /// Creates a new builder-style object to manufacture [`EmptyStruct`](crate::model::EmptyStruct).
     pub fn builder() -> crate::model::empty_struct::Builder {
         crate::model::empty_struct::Builder::default()
-+
+    }
-+
+}
-+
 #[::pyo3::pyclass]
 /// :param path str:
 /// :param message str:
 /// :rtype None:
 /// Describes one specific validation failure for an input member.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationExceptionField {
     #[pyo3(get, set)]
     /// :type str:
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub path: ::std::string::String,
     #[pyo3(get, set)]
     /// :type str:
     /// A detailed description of the validation failure.
     pub message: ::std::string::String,
-+
+}
 impl ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub fn path(&self) -> &str {
         use std::ops::Deref;
         self.path.deref()
-+
+    }
     /// A detailed description of the validation failure.
     pub fn message(&self) -> &str {
         use std::ops::Deref;
         self.message.deref()
-+
+    }
-+
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ValidationExceptionField {
     #[new]
     pub fn new(path: ::std::string::String, message: ::std::string::String) -> Self {
         Self { path, message }
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ValidationExceptionField> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ValidationExceptionField>().map(Box::new)
-+
+    }
-+
+}
-+
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ValidationExceptionField> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-+
+    }
-+
+}
 impl ValidationExceptionField {
     /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     pub fn builder() -> crate::model::validation_exception_field::Builder {
         crate::model::validation_exception_field::Builder::default()
-+
+    }
-+
+}
 pub(crate) mod map_with_enum_key_internal {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub(crate) enum ConstraintViolation {
         #[doc(hidden)]
         Key(crate::model::string_enum_internal::ConstraintViolation),
-+
+    }
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 Self::Key(key_constraint_violation) => write!(f, "{}", key_constraint_violation),
-+
+            }
-+
+        }
-+
+    }
-+
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 Self::Key(key_constraint_violation) => {
                     key_constraint_violation.as_validation_exception_field(path)
-+
+                }
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`EmptyStruct`](crate::model::EmptyStruct).
 pub mod empty_struct {
-449
     impl ::std::convert::From<Builder> for crate::model::EmptyStruct {
         fn from(builder: Builder) -> Self {
             builder.build()
-453
+        }
-454
+    }
     /// A builder for [`EmptyStruct`](crate::model::EmptyStruct).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

↧ Expand context

     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`EmptyStruct`](crate::model::EmptyStruct).
         pub fn build(self) -> crate::model::EmptyStruct {
             self.build_enforcing_required_and_enum_traits()
-462
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::model::EmptyStruct {
             crate::model::EmptyStruct {}
-465
+        }
-466
+    }
-467
+}
 /// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
 pub mod validation_exception_field {
-470
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `path` was not provided but it is required when building `ValidationExceptionField`.
         MissingPath,

@@ -469,500 +529,0 @@

↥ Expand context

         pub(crate) message: ::std::option::Option<::std::string::String>,
-501
+    }
     impl Builder {
         /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
         pub fn path(mut self, input: ::std::string::String) -> Self {
             self.path = Some(input);
             self
-507
+        }
         /// A detailed description of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-512
+        }
         /// Consumes the builder and constructs a [`ValidationExceptionField`](crate::model::ValidationExceptionField).
         ///
         /// The builder fails to construct a [`ValidationExceptionField`](crate::model::ValidationExceptionField) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::model::ValidationExceptionField, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-519
+        }

         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::model::ValidationExceptionField, ConstraintViolation> {
             Ok(crate::model::ValidationExceptionField {
                 path: self.path.ok_or(ConstraintViolation::MissingPath)?,
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-527
+        }
-528
+    }
-529
+}
 pub(crate) mod map_with_enum_key_internal {
--
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub(crate) enum ConstraintViolation {
         #[doc(hidden)]
         Key(crate::model::string_enum_internal::ConstraintViolation),
--
+    }
--
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 Self::Key(key_constraint_violation) => write!(f, "{}", key_constraint_violation),
--
+            }
--
+        }
--
+    }
--
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 Self::Key(key_constraint_violation) => {
                     key_constraint_violation.as_validation_exception_field(path)
--
+                }
--
+            }
--
+        }
--
+    }
--
+}

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/operation.rs

@@ -1,1 +610,526 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpQueryParamsOnlyOperationInput`](crate::input::HttpQueryParamsOnlyOperationInput) using modelled bindings.
     pub struct HttpQueryParamsOnlyOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpQueryParamsOnlyOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpQueryParamsOnlyOperationInputFuture {
     type Output = Result<
         crate::input::HttpQueryParamsOnlyOperationInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
--
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
--
+    }
--
+}
--
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpQueryParamsOnlyOperationInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpQueryParamsOnlyOperationInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_query_params_only_operation::de_http_query_params_only_operation_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpQueryParamsOnlyOperationInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpQueryParamsOnlyOperationOutput
--
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpQueryParamsOnlyOperationError
--
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`StringPayloadInput`](crate::input::StringPayloadInput) using modelled bindings.
     pub struct StringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StringPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7
+    }
-8
+}
-9
 impl std::future::Future for QueryPrecedenceInputFuture {
 impl std::future::Future for StringPayloadInputFuture {
     type Output = Result<
         crate::input::QueryPrecedenceInput,
         crate::input::StringPayloadInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-15
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-22
+    }
-23
+}
-24
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
     > for crate::input::StringPayloadInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-33
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-37
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
     type Future = StringPayloadInputFuture;
-41
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
             crate::protocol_serde::shape_string_payload::de_string_payload_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         QueryPrecedenceInputFuture {
         StringPayloadInputFuture {
             inner: Box::pin(fut),
-60
+        }
-61
+    }
-62
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
     > for crate::output::StringPayloadOutput
-67
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-74
+            }
-75
+        }
-76
+    }
-77
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryPrecedenceError
     > for crate::error::StringPayloadError
-82
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_error(&self)
--
+        {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-92
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-96
+            }
-97
+        }
-98
+    }
-99
+}
-100
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EmptyStructWithContentOnWireOpInput`](crate::input::EmptyStructWithContentOnWireOpInput) using modelled bindings.
     pub struct EmptyStructWithContentOnWireOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyStructWithContentOnWireOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`PrimitiveIntHeaderInput`](crate::input::PrimitiveIntHeaderInput) using modelled bindings.
     pub struct PrimitiveIntHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntHeaderInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-106
+    }
-107
+}
-108
 impl std::future::Future for EmptyStructWithContentOnWireOpInputFuture {
 impl std::future::Future for PrimitiveIntHeaderInputFuture {
     type Output = Result<
         crate::input::EmptyStructWithContentOnWireOpInput,
         crate::input::PrimitiveIntHeaderInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-114
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-121
+    }
-122
+}
-123
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyStructWithContentOnWireOpInput
     > for crate::input::PrimitiveIntHeaderInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-132
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-136
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyStructWithContentOnWireOpInputFuture;
     type Future = PrimitiveIntHeaderInputFuture;
-140
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-148
+            }
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)
                             .await
             crate::protocol_serde::shape_primitive_int_header::de_primitive_int_header_http_request(
                 request,
-+
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         EmptyStructWithContentOnWireOpInputFuture {
         PrimitiveIntHeaderInputFuture {
             inner: Box::pin(fut),
-161
+        }
-162
+    }
-163
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyStructWithContentOnWireOpOutput
     > for crate::output::PrimitiveIntHeaderOutput
-168
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_response(self) {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-175
+                        }
-176
+                    }
-177
+    }
-178
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EmptyStructWithContentOnWireOpError
     > for crate::error::PrimitiveIntHeaderError
-183
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_error(&self) {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-199
+            }
-200
+        }
-201
+    }
-202
+}
-203
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`CaseInsensitiveErrorOperationInput`](crate::input::CaseInsensitiveErrorOperationInput) using modelled bindings.
     pub struct CaseInsensitiveErrorOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::CaseInsensitiveErrorOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`EnumQueryInput`](crate::input::EnumQueryInput) using modelled bindings.
     pub struct EnumQueryInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EnumQueryInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-209
+    }
-210
+}
-211
 impl std::future::Future for CaseInsensitiveErrorOperationInputFuture {
 impl std::future::Future for EnumQueryInputFuture {
     type Output = Result<
         crate::input::CaseInsensitiveErrorOperationInput,
         crate::input::EnumQueryInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-217
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-224
+    }
-225
+}
-226
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CaseInsensitiveErrorOperationInput
     > for crate::input::EnumQueryInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-235
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-239
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CaseInsensitiveErrorOperationInputFuture;
     type Future = EnumQueryInputFuture;
-243
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-251
+            }
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)
                             .await
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         CaseInsensitiveErrorOperationInputFuture {
         EnumQueryInputFuture {
             inner: Box::pin(fut),
-261
+        }
-262
+    }
-263
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CaseInsensitiveErrorOperationOutput
     > for crate::output::EnumQueryOutput
-268
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-277
+    }
-278
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::CaseInsensitiveErrorOperationError
     > for crate::error::EnumQueryError
-283
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_error(&self) {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-297
+            }
-298
+        }
-299
+    }
-300
+}
-301
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullInNonSparseInput`](crate::input::NullInNonSparseInput) using modelled bindings.
     pub struct NullInNonSparseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullInNonSparseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`StatusResponseInput`](crate::input::StatusResponseInput) using modelled bindings.
     pub struct StatusResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StatusResponseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-307
+    }
-308
+}
-309
 impl std::future::Future for NullInNonSparseInputFuture {
 impl std::future::Future for StatusResponseInputFuture {
     type Output = Result<
         crate::input::NullInNonSparseInput,
         crate::input::StatusResponseInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-315
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-322
+    }
-323
+}
-324
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullInNonSparseInput
     > for crate::input::StatusResponseInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-333
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-337
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullInNonSparseInputFuture;
     type Future = StatusResponseInputFuture;
-341
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-349
+            }
             crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(
                 request,
--
+            )
             .await
             crate::protocol_serde::shape_status_response::de_status_response_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         NullInNonSparseInputFuture {
         StatusResponseInputFuture {
             inner: Box::pin(fut),
-360
+        }
-361
+    }
-362
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullInNonSparseOutput
     > for crate::output::StatusResponseOutput
-367
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_response(
             self,
         ) {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_response(self)
-+
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-375
+            }
-376
+        }
-377
+    }
-378
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::NullInNonSparseError
     > for crate::error::StatusResponseError
-383
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_error(
             &self,
         ) {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-393
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-397
+            }
-398
+        }
-399
+    }
-400
+}
-401
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput) using modelled bindings.
     pub struct EscapedStringValuesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EscapedStringValuesInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`MapWithEnumKeyOpInput`](crate::input::MapWithEnumKeyOpInput) using modelled bindings.
     pub struct MapWithEnumKeyOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MapWithEnumKeyOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-407
+    }
-408
+}
-409
 impl std::future::Future for EscapedStringValuesInputFuture {
 impl std::future::Future for MapWithEnumKeyOpInputFuture {
     type Output = Result<
         crate::input::EscapedStringValuesInput,
         crate::input::MapWithEnumKeyOpInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-415
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-422
+    }
-423
+}
-424
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EscapedStringValuesInput
     > for crate::input::MapWithEnumKeyOpInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-433
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-437
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EscapedStringValuesInputFuture;
     type Future = MapWithEnumKeyOpInputFuture;
-441
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-449
+            }
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_request(request)
                             .await
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_request(
                 request,
-+
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         EscapedStringValuesInputFuture {
         MapWithEnumKeyOpInputFuture {
             inner: Box::pin(fut),
-462
+        }
-463
+    }
-464
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EscapedStringValuesOutput
     > for crate::output::MapWithEnumKeyOpOutput
-469
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_response(self) {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-476
+                        }
-477
+                    }
-478
+    }
-479
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EscapedStringValuesError
     > for crate::error::MapWithEnumKeyOpError
-484
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_error(&self) {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-500
+            }
-501
+        }
-502
+    }
-503
+}
-504
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

↧ Expand context

     /// [`PrimitiveIntOpInput`](crate::input::PrimitiveIntOpInput) using modelled bindings.
     pub struct PrimitiveIntOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-510
+    }
-511
+}
-512
 impl std::future::Future for PrimitiveIntOpInputFuture {
     type Output = Result<
         crate::input::PrimitiveIntOpInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-518
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-525
+    }
-526
+}

@@ -663,579 +1192,1097 @@

↥ Expand context

-579
+            }
-580
+        }
-581
+    }
-582
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PrimitiveIntOpError
-587
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_op::ser_primitive_int_op_http_error(&self)
-590
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-598
+            }

             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-602
+            }
-603
+        }
-604
+    }
-605
+}
-606
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MapWithEnumKeyOpInput`](crate::input::MapWithEnumKeyOpInput) using modelled bindings.
     pub struct MapWithEnumKeyOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MapWithEnumKeyOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput) using modelled bindings.
     pub struct EscapedStringValuesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EscapedStringValuesInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-612
+    }
-613
+}
-614
 impl std::future::Future for MapWithEnumKeyOpInputFuture {
 impl std::future::Future for EscapedStringValuesInputFuture {
     type Output = Result<
         crate::input::MapWithEnumKeyOpInput,
         crate::input::EscapedStringValuesInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-620
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-627
+    }
-628
+}
-629
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MapWithEnumKeyOpInput
     > for crate::input::EscapedStringValuesInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-638
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-642
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MapWithEnumKeyOpInputFuture;
     type Future = EscapedStringValuesInputFuture;
-646
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-654
+            }
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_request(
                 request,
--
+            )
             .await
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MapWithEnumKeyOpInputFuture {
         EscapedStringValuesInputFuture {
             inner: Box::pin(fut),
-665
+        }
-666
+    }
-667
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MapWithEnumKeyOpOutput
     > for crate::output::EscapedStringValuesOutput
-672
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_response(self) {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-679
+                        }
-680
+                    }
-681
+    }
-682
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MapWithEnumKeyOpError
     > for crate::error::EscapedStringValuesError
-687
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_error(
             &self,
         ) {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
--
+            }
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-697
+            }
-698
+        }
-699
+    }
-700
+}
-701
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StatusResponseInput`](crate::input::StatusResponseInput) using modelled bindings.
     pub struct StatusResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StatusResponseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`NullInNonSparseInput`](crate::input::NullInNonSparseInput) using modelled bindings.
     pub struct NullInNonSparseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullInNonSparseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-707
+    }
-708
+}
-709
 impl std::future::Future for StatusResponseInputFuture {
 impl std::future::Future for NullInNonSparseInputFuture {
     type Output = Result<
         crate::input::StatusResponseInput,
         crate::input::NullInNonSparseInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-715
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-722
+    }
-723
+}
-724
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StatusResponseInput
     > for crate::input::NullInNonSparseInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-733
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-737
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StatusResponseInputFuture;
     type Future = NullInNonSparseInputFuture;
-741
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-749
+            }
             crate::protocol_serde::shape_status_response::de_status_response_http_request(request)
                 .await
             crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(
                 request,
-+
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         StatusResponseInputFuture {
         NullInNonSparseInputFuture {
             inner: Box::pin(fut),
-762
+        }
-763
+    }
-764
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StatusResponseOutput
     > for crate::output::NullInNonSparseOutput
-769
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_response(self)
--
+        {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-778
+            }
-779
+        }
-780
+    }
-781
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StatusResponseError
     > for crate::error::NullInNonSparseError
-786
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_error(&self) {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-798
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-802
+            }
-803
+        }
-804
+    }
-805
+}
-806
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EnumQueryInput`](crate::input::EnumQueryInput) using modelled bindings.
     pub struct EnumQueryInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EnumQueryInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`CaseInsensitiveErrorOperationInput`](crate::input::CaseInsensitiveErrorOperationInput) using modelled bindings.
     pub struct CaseInsensitiveErrorOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::CaseInsensitiveErrorOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-812
+    }
-813
+}
-814
 impl std::future::Future for EnumQueryInputFuture {
 impl std::future::Future for CaseInsensitiveErrorOperationInputFuture {
     type Output = Result<
         crate::input::EnumQueryInput,
         crate::input::CaseInsensitiveErrorOperationInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-820
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-827
+    }
-828
+}
-829
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EnumQueryInput
     > for crate::input::CaseInsensitiveErrorOperationInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-838
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-842
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EnumQueryInputFuture;
     type Future = CaseInsensitiveErrorOperationInputFuture;
-846
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-854
+            }
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request).await
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         EnumQueryInputFuture {
         CaseInsensitiveErrorOperationInputFuture {
             inner: Box::pin(fut),
-865
+        }
-866
+    }
-867
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EnumQueryOutput
     > for crate::output::CaseInsensitiveErrorOperationOutput
-872
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-881
+    }
-882
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EnumQueryError
     > for crate::error::CaseInsensitiveErrorOperationError
-887
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_error(&self) {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
--
+            }
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-897
+            }
-898
+        }
-899
+    }
-900
+}
-901
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PrimitiveIntHeaderInput`](crate::input::PrimitiveIntHeaderInput) using modelled bindings.
     pub struct PrimitiveIntHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntHeaderInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`EmptyStructWithContentOnWireOpInput`](crate::input::EmptyStructWithContentOnWireOpInput) using modelled bindings.
     pub struct EmptyStructWithContentOnWireOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyStructWithContentOnWireOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-907
+    }
-908
+}
-909
 impl std::future::Future for PrimitiveIntHeaderInputFuture {
 impl std::future::Future for EmptyStructWithContentOnWireOpInputFuture {
     type Output = Result<
         crate::input::PrimitiveIntHeaderInput,
         crate::input::EmptyStructWithContentOnWireOpInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-915
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-922
+    }
-923
+}
-924
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntHeaderInput
     > for crate::input::EmptyStructWithContentOnWireOpInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-933
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-937
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntHeaderInputFuture;
     type Future = EmptyStructWithContentOnWireOpInputFuture;
-941
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-949
+            }
             crate::protocol_serde::shape_primitive_int_header::de_primitive_int_header_http_request(
                 request,
--
+            )
             .await
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         PrimitiveIntHeaderInputFuture {
         EmptyStructWithContentOnWireOpInputFuture {
             inner: Box::pin(fut),
-960
+        }
-961
+    }
-962
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntHeaderOutput
     > for crate::output::EmptyStructWithContentOnWireOpOutput
-967
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_response(self) {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-974
+                        }
-975
+                    }
-976
+    }
-977
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PrimitiveIntHeaderError
     > for crate::error::EmptyStructWithContentOnWireOpError
-982
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_error(
             &self,
         ) {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
--
+            }
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-992
+            }
-993
+        }
-994
+    }
-995
+}
-996
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StringPayloadInput`](crate::input::StringPayloadInput) using modelled bindings.
     pub struct StringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StringPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1002
+    }
-1003
+}
-1004
 impl std::future::Future for StringPayloadInputFuture {
 impl std::future::Future for QueryPrecedenceInputFuture {
     type Output = Result<
         crate::input::StringPayloadInput,
         crate::input::QueryPrecedenceInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1010
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1017
+    }
-1018
+}
-1019
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StringPayloadInput
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1028
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1032
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StringPayloadInputFuture;
     type Future = QueryPrecedenceInputFuture;
-1036
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1044
+            }
             crate::protocol_serde::shape_string_payload::de_string_payload_http_request(request)
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         StringPayloadInputFuture {
         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-1055
+        }
-1056
+    }
-1057
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StringPayloadOutput
     > for crate::output::QueryPrecedenceOutput
-1062
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_response(self) {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1071
+            }
-1072
+        }
-1073
+    }
-1074
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StringPayloadError
     > for crate::error::QueryPrecedenceError
-1079
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_error(&self) {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_error(&self)
-+
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-1090
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");

↧ Expand context

                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1094
+            }
-1095
+        }
-1096
+    }
-1097
+}

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/operation_shape.rs

@@ -1,1 +249,203 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 pub struct HttpQueryParamsOnlyOperation;
--
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for HttpQueryParamsOnlyOperation {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#HttpQueryParamsOnlyOperation",
             "aws.protocoltests.restjson",
             "HttpQueryParamsOnlyOperation",
         );
--
     type Input = crate::input::HttpQueryParamsOnlyOperationInput;
     type Output = crate::output::HttpQueryParamsOnlyOperationOutput;
     type Error = crate::error::HttpQueryParamsOnlyOperationError;
--
+}
--
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for HttpQueryParamsOnlyOperation
--
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
--
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
--
+    }
--
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
--
+    }
--
+}
--
 #[allow(missing_docs)] // documentation missing in model
 pub struct QueryPrecedence;
 pub struct StringPayload;
-4
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for QueryPrecedence {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for StringPayload {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#QueryPrecedence",
             "aws.protocoltests.restjson#StringPayload",
             "aws.protocoltests.restjson",
             "QueryPrecedence",
             "StringPayload",
         );
-12
     type Input = crate::input::QueryPrecedenceInput;
     type Output = crate::output::QueryPrecedenceOutput;
     type Error = crate::error::QueryPrecedenceError;
     type Input = crate::input::StringPayloadInput;
     type Output = crate::output::StringPayloadOutput;
     type Error = crate::error::StringPayloadError;
-16
+}
-17
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for QueryPrecedence
--
+{
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for StringPayload {
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-30
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-33
+    }
-34
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-37
+    }
-38
+}
-39
 #[allow(missing_docs)] // documentation missing in model
 pub struct EmptyStructWithContentOnWireOp;
 pub struct PrimitiveIntHeader;
-42
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for EmptyStructWithContentOnWireOp {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for PrimitiveIntHeader {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#EmptyStructWithContentOnWireOp",
             "aws.protocoltests.restjson#PrimitiveIntHeader",
             "aws.protocoltests.restjson",
             "EmptyStructWithContentOnWireOp",
             "PrimitiveIntHeader",
         );
-50
     type Input = crate::input::EmptyStructWithContentOnWireOpInput;
     type Output = crate::output::EmptyStructWithContentOnWireOpOutput;
     type Error = crate::error::EmptyStructWithContentOnWireOpError;
     type Input = crate::input::PrimitiveIntHeaderInput;
     type Output = crate::output::PrimitiveIntHeaderOutput;
     type Error = crate::error::PrimitiveIntHeaderError;
-54
+}
-55
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for EmptyStructWithContentOnWireOp
     for PrimitiveIntHeader
-58
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-70
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-73
+    }
-74
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-77
+    }
-78
+}
-79
 #[allow(missing_docs)] // documentation missing in model
 pub struct CaseInsensitiveErrorOperation;
 pub struct EnumQuery;
-82
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for CaseInsensitiveErrorOperation {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for EnumQuery {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#CaseInsensitiveErrorOperation",
             "aws.protocoltests.restjson#EnumQuery",
             "aws.protocoltests.restjson",
             "CaseInsensitiveErrorOperation",
             "EnumQuery",
         );
-90
     type Input = crate::input::CaseInsensitiveErrorOperationInput;
     type Output = crate::output::CaseInsensitiveErrorOperationOutput;
     type Error = crate::error::CaseInsensitiveErrorOperationError;
     type Input = crate::input::EnumQueryInput;
     type Output = crate::output::EnumQueryOutput;
     type Error = crate::error::EnumQueryError;
-94
+}
-95
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for CaseInsensitiveErrorOperation
--
+{
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for EnumQuery {
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-108
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-111
+    }
-112
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-115
+    }
-116
+}
-117
 #[allow(missing_docs)] // documentation missing in model
 pub struct NullInNonSparse;
 pub struct StatusResponse;
-120
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for NullInNonSparse {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for StatusResponse {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#NullInNonSparse",
             "aws.protocoltests.restjson#StatusResponse",
             "aws.protocoltests.restjson",
             "NullInNonSparse",
             "StatusResponse",
         );
-128
     type Input = crate::input::NullInNonSparseInput;
     type Output = crate::output::NullInNonSparseOutput;
     type Error = crate::error::NullInNonSparseError;
     type Input = crate::input::StatusResponseInput;
     type Output = crate::output::StatusResponseOutput;
     type Error = crate::error::StatusResponseError;
-132
+}
-133
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for NullInNonSparse
--
+{
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for StatusResponse {
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-146
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-149
+    }
-150
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-153
+    }
-154
+}
-155
 #[allow(missing_docs)] // documentation missing in model
 pub struct EscapedStringValues;
 pub struct MapWithEnumKeyOp;
-158
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for EscapedStringValues {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for MapWithEnumKeyOp {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#EscapedStringValues",
             "aws.protocoltests.restjson#MapWithEnumKeyOp",
             "aws.protocoltests.restjson",
             "EscapedStringValues",
             "MapWithEnumKeyOp",
         );
-166
     type Input = crate::input::EscapedStringValuesInput;
     type Output = crate::output::EscapedStringValuesOutput;
     type Error = crate::error::EscapedStringValuesError;
     type Input = crate::input::MapWithEnumKeyOpInput;
     type Output = crate::output::MapWithEnumKeyOpOutput;
     type Error = crate::error::MapWithEnumKeyOpError;
-170
+}
-171
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for EscapedStringValues
     for MapWithEnumKeyOp
-174
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,

↧ Expand context

         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-186
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-189
+    }
-190
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-193
+    }
-194
+}
-195
 #[allow(missing_docs)] // documentation missing in model
 pub struct PrimitiveIntOp;
-198
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for PrimitiveIntOp {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#PrimitiveIntOp",
             "aws.protocoltests.restjson",

@@ -251,205 +472,432 @@

↥ Expand context

         );
-206
     type Input = crate::input::PrimitiveIntOpInput;
     type Output = crate::output::PrimitiveIntOpOutput;
     type Error = crate::error::PrimitiveIntOpError;
-210
+}
-211
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for PrimitiveIntOp {
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-224

     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-227
+    }
-228
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-231
+    }
-232
+}
-233
 #[allow(missing_docs)] // documentation missing in model
 pub struct MapWithEnumKeyOp;
 pub struct EscapedStringValues;
-236
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for MapWithEnumKeyOp {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for EscapedStringValues {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#MapWithEnumKeyOp",
             "aws.protocoltests.restjson#EscapedStringValues",
             "aws.protocoltests.restjson",
             "MapWithEnumKeyOp",
             "EscapedStringValues",
         );
-244
     type Input = crate::input::MapWithEnumKeyOpInput;
     type Output = crate::output::MapWithEnumKeyOpOutput;
     type Error = crate::error::MapWithEnumKeyOpError;
     type Input = crate::input::EscapedStringValuesInput;
     type Output = crate::output::EscapedStringValuesOutput;
     type Error = crate::error::EscapedStringValuesError;
-248
+}
-249
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for MapWithEnumKeyOp
     for EscapedStringValues
-252
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-264
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-267
+    }
-268
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-271
+    }
-272
+}
-273
 #[allow(missing_docs)] // documentation missing in model
 pub struct StatusResponse;
 pub struct NullInNonSparse;
-276
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for StatusResponse {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for NullInNonSparse {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#StatusResponse",
             "aws.protocoltests.restjson#NullInNonSparse",
             "aws.protocoltests.restjson",
             "StatusResponse",
             "NullInNonSparse",
         );
-284
     type Input = crate::input::StatusResponseInput;
     type Output = crate::output::StatusResponseOutput;
     type Error = crate::error::StatusResponseError;
     type Input = crate::input::NullInNonSparseInput;
     type Output = crate::output::NullInNonSparseOutput;
     type Error = crate::error::NullInNonSparseError;
-288
+}
-289
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for StatusResponse {
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for NullInNonSparse
-+
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-304
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-307
+    }
-308
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-311
+    }
-312
+}
-313
 #[allow(missing_docs)] // documentation missing in model
 pub struct EnumQuery;
 pub struct CaseInsensitiveErrorOperation;
-316
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for EnumQuery {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for CaseInsensitiveErrorOperation {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#EnumQuery",
             "aws.protocoltests.restjson#CaseInsensitiveErrorOperation",
             "aws.protocoltests.restjson",
             "EnumQuery",
             "CaseInsensitiveErrorOperation",
         );
-324
     type Input = crate::input::EnumQueryInput;
     type Output = crate::output::EnumQueryOutput;
     type Error = crate::error::EnumQueryError;
     type Input = crate::input::CaseInsensitiveErrorOperationInput;
     type Output = crate::output::CaseInsensitiveErrorOperationOutput;
     type Error = crate::error::CaseInsensitiveErrorOperationError;
-328
+}
-329
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for EnumQuery {
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for CaseInsensitiveErrorOperation
-+
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-344
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-347
+    }
-348
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-351
+    }
-352
+}
-353
 #[allow(missing_docs)] // documentation missing in model
 pub struct PrimitiveIntHeader;
 pub struct EmptyStructWithContentOnWireOp;
-356
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for PrimitiveIntHeader {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for EmptyStructWithContentOnWireOp {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#PrimitiveIntHeader",
             "aws.protocoltests.restjson#EmptyStructWithContentOnWireOp",
             "aws.protocoltests.restjson",
             "PrimitiveIntHeader",
             "EmptyStructWithContentOnWireOp",
         );
-364
     type Input = crate::input::PrimitiveIntHeaderInput;
     type Output = crate::output::PrimitiveIntHeaderOutput;
     type Error = crate::error::PrimitiveIntHeaderError;
     type Input = crate::input::EmptyStructWithContentOnWireOpInput;
     type Output = crate::output::EmptyStructWithContentOnWireOpOutput;
     type Error = crate::error::EmptyStructWithContentOnWireOpError;
-368
+}
-369
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for PrimitiveIntHeader
     for EmptyStructWithContentOnWireOp
-372
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
     >;
-384
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-387
+    }
-388
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-391
+    }
-392
+}
-393
 #[allow(missing_docs)] // documentation missing in model
 pub struct StringPayload;
 pub struct QueryPrecedence;
-396
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for StringPayload {
 impl ::aws_smithy_legacy_http_server::operation::OperationShape for QueryPrecedence {
     const ID: ::aws_smithy_legacy_http_server::shape_id::ShapeId =
         ::aws_smithy_legacy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#StringPayload",
             "aws.protocoltests.restjson#QueryPrecedence",
             "aws.protocoltests.restjson",
             "StringPayload",
             "QueryPrecedence",
         );
-404
     type Input = crate::input::StringPayloadInput;
     type Output = crate::output::StringPayloadOutput;
     type Error = crate::error::StringPayloadError;
     type Input = crate::input::QueryPrecedenceInput;
     type Output = crate::output::QueryPrecedenceOutput;
     type Error = crate::error::QueryPrecedenceError;
-408
+}
-409
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity for StringPayload {
 impl ::aws_smithy_legacy_http_server::instrumentation::sensitivity::Sensitivity
     for QueryPrecedence
-+
+{
     type RequestFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_legacy_http_server::instrumentation::MakeIdentity,

↧ Expand context

     >;
-424
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::RequestFmt::new()
-427
+    }
-428
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_legacy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-431
+    }
-432
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50