Server Test

Server Test

rev. a7fb2e3446d314cfbe48069306e4e0a389b39aeb (ignoring whitespace)

Files changed:

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

@@ -1451,1451 +1510,1611 @@
 1471   1471   
                response
 1472   1472   
            },
 1473   1473   
            Err(e) => {
 1474   1474   
                ::tracing::error!(error = %e, "failed to serialize response");
 1475   1475   
                ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
 1476   1476   
            }
 1477   1477   
        }
 1478   1478   
    }
 1479   1479   
}
 1480   1480   
        1481  +
const CONTENT_TYPE_CONSTRAINEDLISTWITHINDIRECTLYCONSTRAINEDAGGREGATEOPERATION: ::mime::Mime =
        1482  +
    ::mime::APPLICATION_JSON;
        1483  +
::pin_project_lite::pin_project! {
        1484  +
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
        1485  +
    /// [`ConstrainedListWithIndirectlyConstrainedAggregateOperationInput`](crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput) using modelled bindings.
        1486  +
    pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture {
        1487  +
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
        1488  +
    }
        1489  +
}
        1490  +
        1491  +
impl std::future::Future for ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture {
        1492  +
    type Output = Result<
        1493  +
        crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
        1494  +
        ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
        1495  +
    >;
        1496  +
        1497  +
    fn poll(
        1498  +
        self: std::pin::Pin<&mut Self>,
        1499  +
        cx: &mut std::task::Context<'_>,
        1500  +
    ) -> std::task::Poll<Self::Output> {
        1501  +
        let this = self.project();
        1502  +
        this.inner.as_mut().poll(cx)
        1503  +
    }
        1504  +
}
        1505  +
        1506  +
impl<B>
        1507  +
    ::aws_smithy_http_server::request::FromRequest<
        1508  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
        1509  +
        B,
        1510  +
    > for crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput
        1511  +
where
        1512  +
    B: ::aws_smithy_http_server::body::HttpBody + Send,
        1513  +
    B: 'static,
        1514  +
        1515  +
    B::Data: Send,
        1516  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
        1517  +
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
        1518  +
{
        1519  +
    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
        1520  +
    type Future = ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture;
        1521  +
        1522  +
    fn from_request(request: ::http::Request<B>) -> Self::Future {
        1523  +
        let fut = async move {
        1524  +
            if !::aws_smithy_http_server::protocol::accept_header_classifier(
        1525  +
                request.headers(),
        1526  +
                &CONTENT_TYPE_CONSTRAINEDLISTWITHINDIRECTLYCONSTRAINEDAGGREGATEOPERATION,
        1527  +
            ) {
        1528  +
                return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
        1529  +
            }
        1530  +
            crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::de_constrained_list_with_indirectly_constrained_aggregate_operation_http_request(request)
        1531  +
                            .await
        1532  +
                            .map_err(Into::into)
        1533  +
        };
        1534  +
        use ::futures_util::future::TryFutureExt;
        1535  +
        let fut = fut.map_err(
        1536  +
            |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
        1537  +
                ::tracing::debug!(error = %e, "failed to deserialize request");
        1538  +
                ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
        1539  +
                    e,
        1540  +
                )
        1541  +
            },
        1542  +
        );
        1543  +
        ConstrainedListWithIndirectlyConstrainedAggregateOperationInputFuture {
        1544  +
            inner: Box::pin(fut),
        1545  +
        }
        1546  +
    }
        1547  +
}
        1548  +
impl
        1549  +
    ::aws_smithy_http_server::response::IntoResponse<
        1550  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
        1551  +
    > for crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
        1552  +
{
        1553  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
        1554  +
        match crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_response(self) {
        1555  +
                        Ok(response) => response,
        1556  +
                        Err(e) => {
        1557  +
                            ::tracing::error!(error = %e, "failed to serialize response");
        1558  +
                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
        1559  +
                        }
        1560  +
                    }
        1561  +
    }
        1562  +
}
        1563  +
impl
        1564  +
    ::aws_smithy_http_server::response::IntoResponse<
        1565  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
        1566  +
    > for crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError
        1567  +
{
        1568  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
        1569  +
        match crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_error(&self) {
        1570  +
            Ok(mut response) => {
        1571  +
                response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
        1572  +
                response
        1573  +
            },
        1574  +
            Err(e) => {
        1575  +
                ::tracing::error!(error = %e, "failed to serialize response");
        1576  +
                ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
        1577  +
            }
        1578  +
        }
        1579  +
    }
        1580  +
}
        1581  +
 1481   1582   
const CONTENT_TYPE_CONSTRAINEDRECURSIVESHAPESOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 1482   1583   
::pin_project_lite::pin_project! {
 1483   1584   
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
 1484   1585   
    /// [`ConstrainedRecursiveShapesOperationInput`](crate::input::ConstrainedRecursiveShapesOperationInput) using modelled bindings.
 1485   1586   
    pub struct ConstrainedRecursiveShapesOperationInputFuture {
 1486   1587   
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstrainedRecursiveShapesOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
 1487   1588   
    }
 1488   1589   
}
 1489   1590   
 1490   1591   
impl std::future::Future for ConstrainedRecursiveShapesOperationInputFuture {

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

@@ -594,594 +653,695 @@
  614    614   
  615    615   
    fn request_fmt() -> Self::RequestFmt {
  616    616   
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
  617    617   
    }
  618    618   
  619    619   
    fn response_fmt() -> Self::ResponseFmt {
  620    620   
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
  621    621   
    }
  622    622   
}
  623    623   
         624  +
#[allow(missing_docs)] // documentation missing in model
         625  +
pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperation;
         626  +
         627  +
impl ::aws_smithy_http_server::operation::OperationShape
         628  +
    for ConstrainedListWithIndirectlyConstrainedAggregateOperation
         629  +
{
         630  +
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         631  +
        ::aws_smithy_http_server::shape_id::ShapeId::new(
         632  +
            "com.amazonaws.constraints#ConstrainedListWithIndirectlyConstrainedAggregateOperation",
         633  +
            "com.amazonaws.constraints",
         634  +
            "ConstrainedListWithIndirectlyConstrainedAggregateOperation",
         635  +
        );
         636  +
         637  +
    type Input = crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput;
         638  +
    type Output = crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput;
         639  +
    type Error = crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError;
         640  +
}
         641  +
         642  +
impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
         643  +
    for ConstrainedListWithIndirectlyConstrainedAggregateOperation
         644  +
{
         645  +
    type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         646  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         647  +
        ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
         648  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
         649  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
         650  +
        >,
         651  +
    >;
         652  +
    type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         653  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         654  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         655  +
    >;
         656  +
         657  +
    fn request_fmt() -> Self::RequestFmt {
         658  +
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
         659  +
    }
         660  +
         661  +
    fn response_fmt() -> Self::ResponseFmt {
         662  +
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
         663  +
    }
         664  +
}
         665  +
  624    666   
#[allow(missing_docs)] // documentation missing in model
  625    667   
pub struct ConstrainedRecursiveShapesOperation;
  626    668   
  627    669   
impl ::aws_smithy_http_server::operation::OperationShape for ConstrainedRecursiveShapesOperation {
  628    670   
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
  629    671   
        ::aws_smithy_http_server::shape_id::ShapeId::new(
  630    672   
            "com.amazonaws.constraints#ConstrainedRecursiveShapesOperation",
  631    673   
            "com.amazonaws.constraints",
  632    674   
            "ConstrainedRecursiveShapesOperation",
  633    675   
        );

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/output.rs

@@ -360,360 +419,450 @@
  380    380   
        self.length_map.as_ref()
  381    381   
    }
  382    382   
}
  383    383   
impl QueryParamsTargetingLengthMapOperationOutput {
  384    384   
    /// Creates a new builder-style object to manufacture [`QueryParamsTargetingLengthMapOperationOutput`](crate::output::QueryParamsTargetingLengthMapOperationOutput).
  385    385   
    pub fn builder() -> crate::output::query_params_targeting_length_map_operation_output::Builder {
  386    386   
        crate::output::query_params_targeting_length_map_operation_output::Builder::default()
  387    387   
    }
  388    388   
}
  389    389   
         390  +
#[allow(missing_docs)] // documentation missing in model
         391  +
#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
         392  +
pub struct ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
         393  +
    #[allow(missing_docs)] // documentation missing in model
         394  +
    pub a: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
         395  +
    #[allow(missing_docs)] // documentation missing in model
         396  +
    pub b: ::std::option::Option<
         397  +
        ::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
         398  +
    >,
         399  +
}
         400  +
impl ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
         401  +
    #[allow(missing_docs)] // documentation missing in model
         402  +
    pub fn a(&self) -> ::std::option::Option<&[::std::vec::Vec<::std::string::String>]> {
         403  +
        self.a.as_deref()
         404  +
    }
         405  +
    #[allow(missing_docs)] // documentation missing in model
         406  +
    pub fn b(
         407  +
        &self,
         408  +
    ) -> ::std::option::Option<
         409  +
        &[::std::collections::HashMap<::std::string::String, ::std::string::String>],
         410  +
    > {
         411  +
        self.b.as_deref()
         412  +
    }
         413  +
}
         414  +
impl ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
         415  +
    /// Creates a new builder-style object to manufacture [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
         416  +
    pub fn builder() -> crate::output::constrained_list_with_indirectly_constrained_aggregate_operation_output::Builder{
         417  +
        crate::output::constrained_list_with_indirectly_constrained_aggregate_operation_output::Builder::default()
         418  +
    }
         419  +
}
         420  +
  390    421   
#[allow(missing_docs)] // documentation missing in model
  391    422   
#[derive(
  392    423   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  393    424   
)]
  394    425   
pub struct ConstrainedRecursiveShapesOperationOutput {
  395    426   
    #[allow(missing_docs)] // documentation missing in model
  396    427   
    pub nested: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,
  397    428   
    #[allow(missing_docs)] // documentation missing in model
  398    429   
    pub recursive_list: ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
  399    430   
}
@@ -1434,1465 +1493,1584 @@
 1454   1485   
        }
 1455   1486   
        fn build_enforcing_required_and_enum_traits(
 1456   1487   
            self,
 1457   1488   
        ) -> crate::output::QueryParamsTargetingLengthMapOperationOutput {
 1458   1489   
            crate::output::QueryParamsTargetingLengthMapOperationOutput {
 1459   1490   
                length_map: self.length_map,
 1460   1491   
            }
 1461   1492   
        }
 1462   1493   
    }
 1463   1494   
}
        1495  +
/// See [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
        1496  +
pub mod constrained_list_with_indirectly_constrained_aggregate_operation_output {
        1497  +
        1498  +
    impl ::std::convert::From<Builder>
        1499  +
        for crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
        1500  +
    {
        1501  +
        fn from(builder: Builder) -> Self {
        1502  +
            builder.build()
        1503  +
        }
        1504  +
    }
        1505  +
    /// A builder for [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
        1506  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        1507  +
    pub struct Builder {
        1508  +
        pub(crate) a:
        1509  +
            ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
        1510  +
        pub(crate) b: ::std::option::Option<
        1511  +
            ::std::vec::Vec<
        1512  +
                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        1513  +
            >,
        1514  +
        >,
        1515  +
    }
        1516  +
    impl Builder {
        1517  +
        #[allow(missing_docs)] // documentation missing in model
        1518  +
        pub fn a(
        1519  +
            mut self,
        1520  +
            input: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,
        1521  +
        ) -> Self {
        1522  +
            self.a = input;
        1523  +
            self
        1524  +
        }
        1525  +
        #[allow(missing_docs)] // documentation missing in model
        1526  +
        pub fn b(
        1527  +
            mut self,
        1528  +
            input: ::std::option::Option<
        1529  +
                ::std::vec::Vec<
        1530  +
                    ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        1531  +
                >,
        1532  +
            >,
        1533  +
        ) -> Self {
        1534  +
            self.b = input;
        1535  +
            self
        1536  +
        }
        1537  +
        /// Consumes the builder and constructs a [`ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput`](crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput).
        1538  +
        pub fn build(
        1539  +
            self,
        1540  +
        ) -> crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
        1541  +
        {
        1542  +
            self.build_enforcing_required_and_enum_traits()
        1543  +
        }
        1544  +
        fn build_enforcing_required_and_enum_traits(
        1545  +
            self,
        1546  +
        ) -> crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput
        1547  +
        {
        1548  +
            crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput {
        1549  +
                a: self.a,
        1550  +
                b: self.b,
        1551  +
            }
        1552  +
        }
        1553  +
    }
        1554  +
}
 1464   1555   
/// See [`ConstrainedRecursiveShapesOperationOutput`](crate::output::ConstrainedRecursiveShapesOperationOutput).
 1465   1556   
pub mod constrained_recursive_shapes_operation_output {
 1466   1557   
 1467   1558   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
 1468   1559   
    /// Holds one variant for each of the ways the builder can fail.
 1469   1560   
 1470   1561   
    #[allow(clippy::enum_variant_names)]
 1471   1562   
    pub enum ConstraintViolation {
 1472   1563   
        /// `recursive_list` was not provided but it is required when building `ConstrainedRecursiveShapesOperationOutput`.
 1473   1564   
        MissingRecursiveList,

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde.rs

@@ -1,1 +155,167 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
pub(crate) mod shape_constrained_http_bound_shapes_operation;
    3      3   
    4      4   
pub(crate) mod shape_constrained_http_payload_bound_shape_operation;
    5      5   
           6  +
pub(crate) mod shape_constrained_list_with_indirectly_constrained_aggregate_operation;
           7  +
    6      8   
pub(crate) mod shape_constrained_recursive_shapes_operation;
    7      9   
    8     10   
pub(crate) mod shape_constrained_shapes_only_in_output_operation;
    9     11   
   10     12   
pub(crate) mod shape_constrained_shapes_operation;
   11     13   
   12     14   
pub(crate) mod shape_event_streams_operation;
   13     15   
   14     16   
pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation;
   15     17   
   16     18   
pub(crate) mod shape_non_streaming_blob_operation;
   17     19   
   18     20   
pub(crate) mod shape_query_params_targeting_length_map_operation;
   19     21   
   20     22   
pub(crate) mod shape_query_params_targeting_map_of_enum_string_operation;
   21     23   
   22     24   
pub(crate) mod shape_query_params_targeting_map_of_length_list_of_pattern_string_operation;
   23     25   
   24     26   
pub(crate) mod shape_query_params_targeting_map_of_length_pattern_string_operation;
   25     27   
   26     28   
pub(crate) mod shape_query_params_targeting_map_of_length_string_operation;
   27     29   
   28     30   
pub(crate) mod shape_query_params_targeting_map_of_list_of_enum_string_operation;
   29     31   
   30     32   
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_pattern_string_operation;
   31     33   
   32     34   
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_string_operation;
   33     35   
   34     36   
pub(crate) mod shape_query_params_targeting_map_of_list_of_pattern_string_operation;
   35     37   
   36     38   
pub(crate) mod shape_query_params_targeting_map_of_pattern_string_operation;
   37     39   
   38     40   
pub(crate) mod shape_query_params_targeting_map_of_set_of_length_string_operation;
   39     41   
   40     42   
pub(crate) mod shape_streaming_blob_operation;
   41     43   
   42     44   
pub(crate) mod shape_constrained_http_bound_shapes_operation_input;
   43     45   
   44     46   
pub(crate) mod shape_constrained_http_bound_shapes_operation_output;
   45     47   
   46     48   
pub(crate) mod shape_constrained_http_payload_bound_shape_operation_input;
   47     49   
   48     50   
pub(crate) mod shape_constrained_http_payload_bound_shape_operation_output;
   49     51   
   50     52   
pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
   51     53   
    if data.is_empty() {
   52     54   
        b"{}"
   53     55   
    } else {
   54     56   
        data
   55     57   
    }
   56     58   
}
   57     59   
          60  +
pub(crate) mod shape_constrained_list_with_indirectly_constrained_aggregate_operation_output;
          61  +
   58     62   
pub(crate) mod shape_constrained_recursive_shapes_operation_output;
   59     63   
   60     64   
pub(crate) mod shape_constrained_shapes_only_in_output_operation_output;
   61     65   
   62     66   
pub(crate) mod shape_constrained_shapes_operation_output;
   63     67   
   64     68   
pub(crate) mod shape_event_stream_error_message;
   65     69   
   66     70   
pub(crate) mod shape_event_streams_operation_input;
   67     71   
   68     72   
pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation_input;
   69     73   
   70     74   
pub(crate) mod shape_http_prefix_headers_targeting_length_map_operation_output;
   71     75   
   72     76   
pub(crate) mod shape_non_streaming_blob_operation_input;
   73     77   
   74     78   
pub(crate) mod shape_non_streaming_blob_operation_output;
   75     79   
   76     80   
pub(crate) mod shape_query_params_targeting_length_map_operation_output;
   77     81   
   78     82   
pub(crate) mod shape_query_params_targeting_map_of_enum_string_operation_output;
   79     83   
   80     84   
pub(crate) mod shape_query_params_targeting_map_of_length_list_of_pattern_string_operation_output;
   81     85   
   82     86   
pub(crate) mod shape_query_params_targeting_map_of_length_pattern_string_operation_output;
   83     87   
   84     88   
pub(crate) mod shape_query_params_targeting_map_of_length_string_operation_output;
   85     89   
   86     90   
pub(crate) mod shape_query_params_targeting_map_of_list_of_enum_string_operation_output;
   87     91   
   88     92   
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_pattern_string_operation_output;
   89     93   
   90     94   
pub(crate) mod shape_query_params_targeting_map_of_list_of_length_string_operation_output;
   91     95   
   92     96   
pub(crate) mod shape_query_params_targeting_map_of_list_of_pattern_string_operation_output;
   93     97   
   94     98   
pub(crate) mod shape_query_params_targeting_map_of_pattern_string_operation_output;
   95     99   
   96    100   
pub(crate) mod shape_query_params_targeting_map_of_set_of_length_string_operation_output;
   97    101   
   98    102   
pub(crate) mod shape_streaming_blob_operation_input;
   99    103   
  100    104   
pub(crate) mod shape_streaming_blob_operation_output;
  101    105   
  102    106   
pub(crate) mod shape_validation_exception;
  103    107   
  104    108   
pub(crate) mod shape_con_a;
  105    109   
  106    110   
pub(crate) mod shape_event;
  107    111   
         112  +
pub(crate) mod shape_list_with_indirectly_constrained_list;
         113  +
         114  +
pub(crate) mod shape_list_with_indirectly_constrained_map;
         115  +
  108    116   
pub(crate) mod shape_recursive_list;
  109    117   
  110    118   
pub(crate) mod shape_recursive_shapes_input_output_nested1;
  111    119   
  112    120   
pub(crate) mod shape_con_b;
  113    121   
  114    122   
pub(crate) mod shape_con_b_list;
  115    123   
  116    124   
pub(crate) mod shape_con_b_map;
  117    125   
  118    126   
pub(crate) mod shape_con_b_set;
  119    127   
  120    128   
pub(crate) mod shape_constrained_union;
  121    129   
  122    130   
pub(crate) mod shape_constrained_union_in_output;
  123    131   
  124    132   
pub(crate) mod shape_event_stream_regular_message;
  125    133   
         134  +
pub(crate) mod shape_indirectly_constrained_list;
         135  +
         136  +
pub(crate) mod shape_indirectly_constrained_map;
         137  +
  126    138   
pub(crate) mod shape_length_list;
  127    139   
  128    140   
pub(crate) mod shape_length_list_of_pattern_string;
  129    141   
  130    142   
pub(crate) mod shape_length_map;
  131    143   
  132    144   
pub(crate) mod shape_length_set_of_pattern_string;
  133    145   
  134    146   
pub(crate) mod shape_list_of_length_blob;
  135    147

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde/shape_constrained_list_with_indirectly_constrained_aggregate_operation.rs

@@ -0,1 +0,139 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(clippy::unnecessary_wraps)]
           3  +
pub async fn de_constrained_list_with_indirectly_constrained_aggregate_operation_http_request<B>(
           4  +
    #[allow(unused_variables)] request: ::http::Request<B>,
           5  +
) -> std::result::Result<
           6  +
    crate::input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput,
           7  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
           8  +
>
           9  +
where
          10  +
    B: ::aws_smithy_http_server::body::HttpBody + Send,
          11  +
    B::Data: Send,
          12  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
          13  +
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
          14  +
{
          15  +
    Ok({
          16  +
        #[allow(unused_mut)]
          17  +
        let mut input = crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input_internal::Builder::default();
          18  +
        #[allow(unused_variables)]
          19  +
        let ::aws_smithy_runtime_api::http::RequestParts {
          20  +
            uri, headers, body, ..
          21  +
        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
          22  +
        let bytes = ::hyper::body::to_bytes(body).await?;
          23  +
        if !bytes.is_empty() {
          24  +
            ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
          25  +
                &headers,
          26  +
                Some("application/json"),
          27  +
            )?;
          28  +
            input = crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation::de_constrained_list_with_indirectly_constrained_aggregate_operation(bytes.as_ref(), input)?;
          29  +
        }
          30  +
        input.build()?
          31  +
    })
          32  +
}
          33  +
          34  +
#[allow(clippy::unnecessary_wraps)]
          35  +
pub fn ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_response(
          36  +
    #[allow(unused_variables)]
          37  +
    output: crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput,
          38  +
) -> std::result::Result<
          39  +
    ::aws_smithy_http_server::response::Response,
          40  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
          41  +
> {
          42  +
    Ok({
          43  +
        #[allow(unused_mut)]
          44  +
        let mut builder = ::http::Response::builder();
          45  +
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
          46  +
            builder,
          47  +
            ::http::header::CONTENT_TYPE,
          48  +
            "application/json",
          49  +
        );
          50  +
        let http_status: u16 = 200;
          51  +
        builder = builder.status(http_status);
          52  +
        let payload =
          53  +
            crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation_output::ser_constrained_list_with_indirectly_constrained_aggregate_operation_output_output_output(&output)?
          54  +
        ;
          55  +
        let content_length = payload.len();
          56  +
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
          57  +
            builder,
          58  +
            ::http::header::CONTENT_LENGTH,
          59  +
            content_length,
          60  +
        );
          61  +
        let body = ::aws_smithy_http_server::body::to_boxed(payload);
          62  +
        builder.body(body)?
          63  +
    })
          64  +
}
          65  +
          66  +
#[allow(clippy::unnecessary_wraps)]
          67  +
pub fn ser_constrained_list_with_indirectly_constrained_aggregate_operation_http_error(
          68  +
    error: &crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError,
          69  +
) -> std::result::Result<
          70  +
    ::aws_smithy_http_server::response::Response,
          71  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
          72  +
> {
          73  +
    Ok({
          74  +
        match error {
          75  +
            crate::error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError::ValidationException(output) => {
          76  +
                let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
          77  +
                #[allow(unused_mut)]
          78  +
                let mut builder = ::http::Response::builder();
          79  +
                builder = ::aws_smithy_http::header::set_response_header_if_absent(
          80  +
                                builder,
          81  +
                                ::http::header::CONTENT_TYPE,
          82  +
                                "application/json",
          83  +
                            );
          84  +
                builder = ::aws_smithy_http::header::set_response_header_if_absent(
          85  +
                                builder,
          86  +
                                ::http::header::HeaderName::from_static("x-amzn-errortype"),
          87  +
                                "ValidationException",
          88  +
                            );
          89  +
                let content_length = payload.len();
          90  +
                            builder = ::aws_smithy_http::header::set_response_header_if_absent(builder, ::http::header::CONTENT_LENGTH, content_length);
          91  +
                builder.status(400).body(::aws_smithy_http_server::body::to_boxed(payload))?
          92  +
            }
          93  +
        }
          94  +
    })
          95  +
}
          96  +
          97  +
pub(crate) fn de_constrained_list_with_indirectly_constrained_aggregate_operation(value: &[u8], mut builder: crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input_internal::Builder) -> Result<crate::input::constrained_list_with_indirectly_constrained_aggregate_operation_input_internal::Builder, ::aws_smithy_json::deserialize::error::DeserializeError>{
          98  +
    let mut tokens_owned =
          99  +
        ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value))
         100  +
            .peekable();
         101  +
    let tokens = &mut tokens_owned;
         102  +
    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
         103  +
    loop {
         104  +
        match tokens.next().transpose()? {
         105  +
            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
         106  +
            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
         107  +
                match key.to_unescaped()?.as_ref() {
         108  +
                    "a" => {
         109  +
                        builder = builder.set_a(
         110  +
                            crate::protocol_serde::shape_list_with_indirectly_constrained_list::de_list_with_indirectly_constrained_list(tokens)?
         111  +
                        );
         112  +
                    }
         113  +
                    "b" => {
         114  +
                        builder = builder.set_b(
         115  +
                            crate::protocol_serde::shape_list_with_indirectly_constrained_map::de_list_with_indirectly_constrained_map(tokens)?
         116  +
                        );
         117  +
                    }
         118  +
                    _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
         119  +
                }
         120  +
            }
         121  +
            other => {
         122  +
                return Err(
         123  +
                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
         124  +
                        "expected object key or end object, found: {:?}",
         125  +
                        other
         126  +
                    )),
         127  +
                )
         128  +
            }
         129  +
        }
         130  +
    }
         131  +
    if tokens.next().is_some() {
         132  +
        return Err(
         133  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
         134  +
                "found more JSON tokens after completing parsing",
         135  +
            ),
         136  +
        );
         137  +
    }
         138  +
    Ok(builder)
         139  +
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde/shape_constrained_list_with_indirectly_constrained_aggregate_operation_output.rs

@@ -0,1 +0,48 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub fn ser_constrained_list_with_indirectly_constrained_aggregate_operation_output_output_output(
           3  +
    value: &crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput,
           4  +
) -> Result<String, ::aws_smithy_types::error::operation::SerializationError> {
           5  +
    let mut out = ::std::string::String::new();
           6  +
    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
           7  +
    crate::protocol_serde::shape_constrained_list_with_indirectly_constrained_aggregate_operation_output::ser_constrained_list_with_indirectly_constrained_aggregate_operation_output_output(&mut object, value)?;
           8  +
    object.finish();
           9  +
    Ok(out)
          10  +
}
          11  +
          12  +
pub fn ser_constrained_list_with_indirectly_constrained_aggregate_operation_output_output(
          13  +
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
          14  +
    input: &crate::output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput,
          15  +
) -> Result<(), ::aws_smithy_types::error::operation::SerializationError> {
          16  +
    if let Some(var_1) = &input.a {
          17  +
        let mut array_2 = object.key("a").start_array();
          18  +
        for item_3 in var_1 {
          19  +
            {
          20  +
                let mut array_4 = array_2.value().start_array();
          21  +
                for item_5 in item_3 {
          22  +
                    {
          23  +
                        array_4.value().string(item_5.as_str());
          24  +
                    }
          25  +
                }
          26  +
                array_4.finish();
          27  +
            }
          28  +
        }
          29  +
        array_2.finish();
          30  +
    }
          31  +
    if let Some(var_6) = &input.b {
          32  +
        let mut array_7 = object.key("b").start_array();
          33  +
        for item_8 in var_6 {
          34  +
            {
          35  +
                #[allow(unused_mut)]
          36  +
                let mut object_9 = array_7.value().start_object();
          37  +
                for (key_10, value_11) in item_8 {
          38  +
                    {
          39  +
                        object_9.key(key_10.as_str()).string(value_11.as_str());
          40  +
                    }
          41  +
                }
          42  +
                object_9.finish();
          43  +
            }
          44  +
        }
          45  +
        array_7.finish();
          46  +
    }
          47  +
    Ok(())
          48  +
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde/shape_indirectly_constrained_list.rs

@@ -0,1 +0,40 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) fn de_indirectly_constrained_list<'a, I>(tokens: &mut ::std::iter::Peekable<I>) -> Result<Option<crate::unconstrained::indirectly_constrained_list_unconstrained::IndirectlyConstrainedListUnconstrained>, ::aws_smithy_json::deserialize::error::DeserializeError>
           3  +
where I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>{
           4  +
    match tokens.next().transpose()? {
           5  +
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
           6  +
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
           7  +
            let mut items = Vec::new();
           8  +
            loop {
           9  +
                match tokens.peek() {
          10  +
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          11  +
                        tokens.next().transpose().unwrap();
          12  +
                        break;
          13  +
                    }
          14  +
                    _ => {
          15  +
                        let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
          16  +
                            tokens.next(),
          17  +
                        )?
          18  +
                        .map(|s| s.to_unescaped().map(|u| u.into_owned()))
          19  +
                        .transpose()?;
          20  +
                        if let Some(value) = value {
          21  +
                            items.push(value);
          22  +
                        } else {
          23  +
                            return Err(
          24  +
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          25  +
                                    "dense list cannot contain null values",
          26  +
                                ),
          27  +
                            );
          28  +
                        }
          29  +
                    }
          30  +
                }
          31  +
            }
          32  +
            Ok(Some(crate::unconstrained::indirectly_constrained_list_unconstrained::IndirectlyConstrainedListUnconstrained(items)))
          33  +
        }
          34  +
        _ => Err(
          35  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          36  +
                "expected start array or null",
          37  +
            ),
          38  +
        ),
          39  +
    }
          40  +
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde/shape_indirectly_constrained_map.rs

@@ -0,1 +0,48 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) fn de_indirectly_constrained_map<'a, I>(tokens: &mut ::std::iter::Peekable<I>) -> Result<Option<crate::unconstrained::indirectly_constrained_map_unconstrained::IndirectlyConstrainedMapUnconstrained>, ::aws_smithy_json::deserialize::error::DeserializeError>
           3  +
where I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>{
           4  +
    match tokens.next().transpose()? {
           5  +
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
           6  +
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
           7  +
            let mut map = ::std::collections::HashMap::new();
           8  +
            loop {
           9  +
                match tokens.next().transpose()? {
          10  +
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
          11  +
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
          12  +
                        let key = key.to_unescaped().map(|u| u.into_owned())?;
          13  +
                        let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
          14  +
                            tokens.next(),
          15  +
                        )?
          16  +
                        .map(|s| s.to_unescaped().map(|u| u.into_owned()))
          17  +
                        .transpose()?;
          18  +
                        match value {
          19  +
                            Some(value) => {
          20  +
                                map.insert(key, value);
          21  +
                            }
          22  +
                            None => {
          23  +
                                return Err(
          24  +
                                    ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          25  +
                                        "dense map cannot contain null values",
          26  +
                                    ),
          27  +
                                )
          28  +
                            }
          29  +
                        }
          30  +
                    }
          31  +
                    other => {
          32  +
                        return Err(
          33  +
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          34  +
                                format!("expected object key or end object, found: {:?}", other),
          35  +
                            ),
          36  +
                        )
          37  +
                    }
          38  +
                }
          39  +
            }
          40  +
            Ok(Some(crate::unconstrained::indirectly_constrained_map_unconstrained::IndirectlyConstrainedMapUnconstrained(map)))
          41  +
        }
          42  +
        _ => Err(
          43  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          44  +
                "expected start object or null",
          45  +
            ),
          46  +
        ),
          47  +
    }
          48  +
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde/shape_list_with_indirectly_constrained_list.rs

@@ -0,1 +0,38 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) fn de_list_with_indirectly_constrained_list<'a, I>(tokens: &mut ::std::iter::Peekable<I>) -> Result<Option<crate::unconstrained::list_with_indirectly_constrained_list_unconstrained::ListWithIndirectlyConstrainedListUnconstrained>, ::aws_smithy_json::deserialize::error::DeserializeError>
           3  +
where I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>{
           4  +
    match tokens.next().transpose()? {
           5  +
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
           6  +
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
           7  +
            let mut items = Vec::new();
           8  +
            loop {
           9  +
                match tokens.peek() {
          10  +
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          11  +
                        tokens.next().transpose().unwrap();
          12  +
                        break;
          13  +
                    }
          14  +
                    _ => {
          15  +
                        let value =
          16  +
                            crate::protocol_serde::shape_indirectly_constrained_list::de_indirectly_constrained_list(tokens)?
          17  +
                        ;
          18  +
                        if let Some(value) = value {
          19  +
                            items.push(value);
          20  +
                        } else {
          21  +
                            return Err(
          22  +
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          23  +
                                    "dense list cannot contain null values",
          24  +
                                ),
          25  +
                            );
          26  +
                        }
          27  +
                    }
          28  +
                }
          29  +
            }
          30  +
            Ok(Some(crate::unconstrained::list_with_indirectly_constrained_list_unconstrained::ListWithIndirectlyConstrainedListUnconstrained(items)))
          31  +
        }
          32  +
        _ => Err(
          33  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          34  +
                "expected start array or null",
          35  +
            ),
          36  +
        ),
          37  +
    }
          38  +
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/protocol_serde/shape_list_with_indirectly_constrained_map.rs

@@ -0,1 +0,38 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) fn de_list_with_indirectly_constrained_map<'a, I>(tokens: &mut ::std::iter::Peekable<I>) -> Result<Option<crate::unconstrained::list_with_indirectly_constrained_map_unconstrained::ListWithIndirectlyConstrainedMapUnconstrained>, ::aws_smithy_json::deserialize::error::DeserializeError>
           3  +
where I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>{
           4  +
    match tokens.next().transpose()? {
           5  +
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
           6  +
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
           7  +
            let mut items = Vec::new();
           8  +
            loop {
           9  +
                match tokens.peek() {
          10  +
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          11  +
                        tokens.next().transpose().unwrap();
          12  +
                        break;
          13  +
                    }
          14  +
                    _ => {
          15  +
                        let value =
          16  +
                            crate::protocol_serde::shape_indirectly_constrained_map::de_indirectly_constrained_map(tokens)?
          17  +
                        ;
          18  +
                        if let Some(value) = value {
          19  +
                            items.push(value);
          20  +
                        } else {
          21  +
                            return Err(
          22  +
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          23  +
                                    "dense list cannot contain null values",
          24  +
                                ),
          25  +
                            );
          26  +
                        }
          27  +
                    }
          28  +
                }
          29  +
            }
          30  +
            Ok(Some(crate::unconstrained::list_with_indirectly_constrained_map_unconstrained::ListWithIndirectlyConstrainedMapUnconstrained(items)))
          31  +
        }
          32  +
        _ => Err(
          33  +
            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
          34  +
                "expected start array or null",
          35  +
            ),
          36  +
        ),
          37  +
    }
          38  +
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/service.rs

@@ -1,1 +38,40 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// The service builder for [`ConstraintsService`].
    3      3   
///
    4      4   
/// Constructed via [`ConstraintsService::builder`].
    5      5   
pub struct ConstraintsServiceBuilder<Body, L, HttpPl, ModelPl> {
    6      6   
    constrained_http_bound_shapes_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
    7      7   
    constrained_http_payload_bound_shape_operation:
    8      8   
        Option<::aws_smithy_http_server::routing::Route<Body>>,
           9  +
    constrained_list_with_indirectly_constrained_aggregate_operation:
          10  +
        Option<::aws_smithy_http_server::routing::Route<Body>>,
    9     11   
    constrained_recursive_shapes_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
   10     12   
    constrained_shapes_only_in_output_operation:
   11     13   
        Option<::aws_smithy_http_server::routing::Route<Body>>,
   12     14   
    constrained_shapes_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
   13     15   
    event_streams_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
   14     16   
    http_prefix_headers_targeting_length_map_operation:
   15     17   
        Option<::aws_smithy_http_server::routing::Route<Body>>,
   16     18   
    non_streaming_blob_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
   17     19   
    query_params_targeting_length_map_operation:
   18     20   
        Option<::aws_smithy_http_server::routing::Route<Body>>,
@@ -324,326 +383,539 @@
  344    346   
            > + Clone
  345    347   
            + Send
  346    348   
            + 'static,
  347    349   
        S::Future: Send + 'static,
  348    350   
    {
  349    351   
        self.constrained_http_payload_bound_shape_operation =
  350    352   
            Some(::aws_smithy_http_server::routing::Route::new(svc));
  351    353   
        self
  352    354   
    }
  353    355   
         356  +
    /// Sets the [`ConstrainedListWithIndirectlyConstrainedAggregateOperation`](crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation) operation.
         357  +
    ///
         358  +
    /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.
         359  +
    /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.
         360  +
    ///
         361  +
    /// # Example
         362  +
    ///
         363  +
    /// ```no_run
         364  +
    /// use constraints_without_public_constrained_types::{ConstraintsService, ConstraintsServiceConfig};
         365  +
    ///
         366  +
    /// use constraints_without_public_constrained_types::{input, output, error};
         367  +
    ///
         368  +
    /// async fn handler(input: input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput) -> Result<output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput, error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError> {
         369  +
    ///     todo!()
         370  +
    /// }
         371  +
    ///
         372  +
    /// let config = ConstraintsServiceConfig::builder().build();
         373  +
    /// let app = ConstraintsService::builder(config)
         374  +
    ///     .constrained_list_with_indirectly_constrained_aggregate_operation(handler)
         375  +
    ///     /* Set other handlers */
         376  +
    ///     .build()
         377  +
    ///     .unwrap();
         378  +
    /// # let app: ConstraintsService<::aws_smithy_http_server::routing::RoutingService<::aws_smithy_http_server::protocol::rest::router::RestRouter<::aws_smithy_http_server::routing::Route>, ::aws_smithy_http_server::protocol::rest_json_1::RestJson1>> = app;
         379  +
    /// ```
         380  +
    ///
         381  +
                    pub fn constrained_list_with_indirectly_constrained_aggregate_operation<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self
         382  +
                    where
         383  +
                        HandlerType: ::aws_smithy_http_server::operation::Handler<crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation, HandlerExtractors>,
         384  +
         385  +
                        ModelPl: ::aws_smithy_http_server::plugin::Plugin<
         386  +
                            ConstraintsService<L>,
         387  +
                            crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         388  +
                            ::aws_smithy_http_server::operation::IntoService<crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation, HandlerType>
         389  +
                        >,
         390  +
                        ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<
         391  +
                            ConstraintsService<L>,
         392  +
                            crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         393  +
                            ModelPl::Output
         394  +
                        >,
         395  +
                        HttpPl: ::aws_smithy_http_server::plugin::Plugin<
         396  +
                            ConstraintsService<L>,
         397  +
                            crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         398  +
                            <
         399  +
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
         400  +
                                as ::aws_smithy_http_server::plugin::Plugin<
         401  +
                                    ConstraintsService<L>,
         402  +
                                    crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         403  +
                                    ModelPl::Output
         404  +
                                >
         405  +
                            >::Output
         406  +
                        >,
         407  +
         408  +
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         409  +
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         410  +
         411  +
                    {
         412  +
        use ::aws_smithy_http_server::operation::OperationShapeExt;
         413  +
        use ::aws_smithy_http_server::plugin::Plugin;
         414  +
        let svc = crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation::from_handler(handler);
         415  +
        let svc = self.model_plugin.apply(svc);
         416  +
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
         417  +
            .apply(svc);
         418  +
        let svc = self.http_plugin.apply(svc);
         419  +
        self.constrained_list_with_indirectly_constrained_aggregate_operation_custom(svc)
         420  +
    }
         421  +
         422  +
    /// Sets the [`ConstrainedListWithIndirectlyConstrainedAggregateOperation`](crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation) operation.
         423  +
    ///
         424  +
    /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.
         425  +
    /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.
         426  +
    ///
         427  +
    /// # Example
         428  +
    ///
         429  +
    /// ```no_run
         430  +
    /// use constraints_without_public_constrained_types::{ConstraintsService, ConstraintsServiceConfig};
         431  +
    ///
         432  +
    /// use constraints_without_public_constrained_types::{input, output, error};
         433  +
    ///
         434  +
    /// async fn handler(input: input::ConstrainedListWithIndirectlyConstrainedAggregateOperationInput) -> Result<output::ConstrainedListWithIndirectlyConstrainedAggregateOperationOutput, error::ConstrainedListWithIndirectlyConstrainedAggregateOperationError> {
         435  +
    ///     todo!()
         436  +
    /// }
         437  +
    ///
         438  +
    /// let config = ConstraintsServiceConfig::builder().build();
         439  +
    /// let svc = ::tower::util::service_fn(handler);
         440  +
    /// let app = ConstraintsService::builder(config)
         441  +
    ///     .constrained_list_with_indirectly_constrained_aggregate_operation_service(svc)
         442  +
    ///     /* Set other handlers */
         443  +
    ///     .build()
         444  +
    ///     .unwrap();
         445  +
    /// # let app: ConstraintsService<::aws_smithy_http_server::routing::RoutingService<::aws_smithy_http_server::protocol::rest::router::RestRouter<::aws_smithy_http_server::routing::Route>, ::aws_smithy_http_server::protocol::rest_json_1::RestJson1>> = app;
         446  +
    /// ```
         447  +
    ///
         448  +
                    pub fn constrained_list_with_indirectly_constrained_aggregate_operation_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self
         449  +
                    where
         450  +
                        S: ::aws_smithy_http_server::operation::OperationService<crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation, ServiceExtractors>,
         451  +
         452  +
                        ModelPl: ::aws_smithy_http_server::plugin::Plugin<
         453  +
                            ConstraintsService<L>,
         454  +
                            crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         455  +
                            ::aws_smithy_http_server::operation::Normalize<crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation, S>
         456  +
                        >,
         457  +
                        ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<
         458  +
                            ConstraintsService<L>,
         459  +
                            crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         460  +
                            ModelPl::Output
         461  +
                        >,
         462  +
                        HttpPl: ::aws_smithy_http_server::plugin::Plugin<
         463  +
                            ConstraintsService<L>,
         464  +
                            crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         465  +
                            <
         466  +
                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>
         467  +
                                as ::aws_smithy_http_server::plugin::Plugin<
         468  +
                                    ConstraintsService<L>,
         469  +
                                    crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
         470  +
                                    ModelPl::Output
         471  +
                                >
         472  +
                            >::Output
         473  +
                        >,
         474  +
         475  +
                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,
         476  +
                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,
         477  +
         478  +
                    {
         479  +
        use ::aws_smithy_http_server::operation::OperationShapeExt;
         480  +
        use ::aws_smithy_http_server::plugin::Plugin;
         481  +
        let svc = crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation::from_service(service);
         482  +
        let svc = self.model_plugin.apply(svc);
         483  +
        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()
         484  +
            .apply(svc);
         485  +
        let svc = self.http_plugin.apply(svc);
         486  +
        self.constrained_list_with_indirectly_constrained_aggregate_operation_custom(svc)
         487  +
    }
         488  +
         489  +
    /// Sets the [`ConstrainedListWithIndirectlyConstrainedAggregateOperation`](crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation) to a custom [`Service`](tower::Service).
         490  +
    /// not constrained by the Smithy contract.
         491  +
    fn constrained_list_with_indirectly_constrained_aggregate_operation_custom<S>(
         492  +
        mut self,
         493  +
        svc: S,
         494  +
    ) -> Self
         495  +
    where
         496  +
        S: ::tower::Service<
         497  +
                ::http::Request<Body>,
         498  +
                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,
         499  +
                Error = ::std::convert::Infallible,
         500  +
            > + Clone
         501  +
            + Send
         502  +
            + 'static,
         503  +
        S::Future: Send + 'static,
         504  +
    {
         505  +
        self.constrained_list_with_indirectly_constrained_aggregate_operation =
         506  +
            Some(::aws_smithy_http_server::routing::Route::new(svc));
         507  +
        self
         508  +
    }
         509  +
  354    510   
    /// Sets the [`ConstrainedRecursiveShapesOperation`](crate::operation_shape::ConstrainedRecursiveShapesOperation) operation.
  355    511   
    ///
  356    512   
    /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.
  357    513   
    /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.
  358    514   
    ///
  359    515   
    /// # Example
  360    516   
    ///
  361    517   
    /// ```no_run
  362    518   
    /// use constraints_without_public_constrained_types::{ConstraintsService, ConstraintsServiceConfig};
  363    519   
    ///
@@ -3131,3287 +3190,3352 @@
 3151   3307   
            }
 3152   3308   
            if self
 3153   3309   
                .constrained_http_payload_bound_shape_operation
 3154   3310   
                .is_none()
 3155   3311   
            {
 3156   3312   
                missing_operation_names.insert(
 3157   3313   
                    crate::operation_shape::ConstrainedHttpPayloadBoundShapeOperation::ID,
 3158   3314   
                    ".constrained_http_payload_bound_shape_operation()",
 3159   3315   
                );
 3160   3316   
            }
        3317  +
            if self
        3318  +
                .constrained_list_with_indirectly_constrained_aggregate_operation
        3319  +
                .is_none()
        3320  +
            {
        3321  +
                missing_operation_names.insert(crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation::ID, ".constrained_list_with_indirectly_constrained_aggregate_operation()");
        3322  +
            }
 3161   3323   
            if self.constrained_recursive_shapes_operation.is_none() {
 3162   3324   
                missing_operation_names.insert(
 3163   3325   
                    crate::operation_shape::ConstrainedRecursiveShapesOperation::ID,
 3164   3326   
                    ".constrained_recursive_shapes_operation()",
 3165   3327   
                );
 3166   3328   
            }
 3167   3329   
            if self.constrained_shapes_only_in_output_operation.is_none() {
 3168   3330   
                missing_operation_names.insert(
 3169   3331   
                    crate::operation_shape::ConstrainedShapesOnlyInOutputOperation::ID,
 3170   3332   
                    ".constrained_shapes_only_in_output_operation()",
@@ -3269,3431 +3383,3553 @@
 3289   3451   
                    operation_names2setter_methods: missing_operation_names,
 3290   3452   
                });
 3291   3453   
            }
 3292   3454   
            let unexpected_error_msg = "this should never panic since we are supposed to check beforehand that a handler has been registered for this operation; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues";
 3293   3455   
 3294   3456   
            crate::model::LengthPatternString::compile_regex();
 3295   3457   
            crate::model::PatternString::compile_regex();
 3296   3458   
 3297   3459   
            ::aws_smithy_http_server::protocol::rest::router::RestRouter::from_iter([(request_specs::constrained_http_bound_shapes_operation(), self.constrained_http_bound_shapes_operation.expect(unexpected_error_msg)),
 3298   3460   
(request_specs::constrained_http_payload_bound_shape_operation(), self.constrained_http_payload_bound_shape_operation.expect(unexpected_error_msg)),
        3461  +
(request_specs::constrained_list_with_indirectly_constrained_aggregate_operation(), self.constrained_list_with_indirectly_constrained_aggregate_operation.expect(unexpected_error_msg)),
 3299   3462   
(request_specs::constrained_recursive_shapes_operation(), self.constrained_recursive_shapes_operation.expect(unexpected_error_msg)),
 3300   3463   
(request_specs::constrained_shapes_only_in_output_operation(), self.constrained_shapes_only_in_output_operation.expect(unexpected_error_msg)),
 3301   3464   
(request_specs::constrained_shapes_operation(), self.constrained_shapes_operation.expect(unexpected_error_msg)),
 3302   3465   
(request_specs::event_streams_operation(), self.event_streams_operation.expect(unexpected_error_msg)),
 3303   3466   
(request_specs::http_prefix_headers_targeting_length_map_operation(), self.http_prefix_headers_targeting_length_map_operation.expect(unexpected_error_msg)),
 3304   3467   
(request_specs::non_streaming_blob_operation(), self.non_streaming_blob_operation.expect(unexpected_error_msg)),
 3305   3468   
(request_specs::query_params_targeting_length_map_operation(), self.query_params_targeting_length_map_operation.expect(unexpected_error_msg)),
 3306   3469   
(request_specs::query_params_targeting_map_of_enum_string_operation(), self.query_params_targeting_map_of_enum_string_operation.expect(unexpected_error_msg)),
 3307   3470   
(request_specs::query_params_targeting_map_of_length_list_of_pattern_string_operation(), self.query_params_targeting_map_of_length_list_of_pattern_string_operation.expect(unexpected_error_msg)),
 3308   3471   
(request_specs::query_params_targeting_map_of_length_pattern_string_operation(), self.query_params_targeting_map_of_length_pattern_string_operation.expect(unexpected_error_msg)),
 3309   3472   
(request_specs::query_params_targeting_map_of_length_string_operation(), self.query_params_targeting_map_of_length_string_operation.expect(unexpected_error_msg)),
 3310   3473   
(request_specs::query_params_targeting_map_of_list_of_enum_string_operation(), self.query_params_targeting_map_of_list_of_enum_string_operation.expect(unexpected_error_msg)),
 3311   3474   
(request_specs::query_params_targeting_map_of_list_of_length_pattern_string_operation(), self.query_params_targeting_map_of_list_of_length_pattern_string_operation.expect(unexpected_error_msg)),
 3312   3475   
(request_specs::query_params_targeting_map_of_list_of_length_string_operation(), self.query_params_targeting_map_of_list_of_length_string_operation.expect(unexpected_error_msg)),
 3313   3476   
(request_specs::query_params_targeting_map_of_list_of_pattern_string_operation(), self.query_params_targeting_map_of_list_of_pattern_string_operation.expect(unexpected_error_msg)),
 3314   3477   
(request_specs::query_params_targeting_map_of_pattern_string_operation(), self.query_params_targeting_map_of_pattern_string_operation.expect(unexpected_error_msg)),
 3315   3478   
(request_specs::query_params_targeting_map_of_set_of_length_string_operation(), self.query_params_targeting_map_of_set_of_length_string_operation.expect(unexpected_error_msg)),
 3316   3479   
(request_specs::streaming_blob_operation(), self.streaming_blob_operation.expect(unexpected_error_msg)),])
 3317   3480   
        };
 3318   3481   
        let svc = ::aws_smithy_http_server::routing::RoutingService::new(router);
 3319   3482   
        let svc = svc.map(|s| s.layer(self.layer));
 3320   3483   
        Ok(ConstraintsService { svc })
 3321   3484   
    }
 3322   3485   
 3323   3486   
    /// Constructs a [`ConstraintsService`] from the arguments provided to the builder.
 3324   3487   
    /// Operations without a handler default to returning 500 Internal Server Error to the caller.
 3325   3488   
    ///
 3326   3489   
    /// Check out [`ConstraintsServiceBuilder::build`] if you'd prefer the builder to fail if one or more operations do
 3327   3490   
    /// not have a registered handler.
 3328   3491   
    pub fn build_unchecked(self) -> ConstraintsService<L::Service>
 3329   3492   
    where
 3330   3493   
        Body: Send + 'static,
 3331   3494   
        L: ::tower::Layer<
 3332   3495   
            ::aws_smithy_http_server::routing::RoutingService<
 3333   3496   
                ::aws_smithy_http_server::protocol::rest::router::RestRouter<
 3334   3497   
                    ::aws_smithy_http_server::routing::Route<Body>,
 3335   3498   
                >,
 3336   3499   
                ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
 3337   3500   
            >,
 3338   3501   
        >,
 3339   3502   
    {
 3340   3503   
        let router = ::aws_smithy_http_server::protocol::rest::router::RestRouter::from_iter([(
 3341   3504   
                                request_specs::constrained_http_bound_shapes_operation(),
 3342   3505   
                                self.constrained_http_bound_shapes_operation.unwrap_or_else(|| {
 3343   3506   
                                    let svc = ::aws_smithy_http_server::operation::MissingFailure::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::default();
 3344   3507   
                                    ::aws_smithy_http_server::routing::Route::new(svc)
 3345   3508   
                                })
 3346   3509   
                            ),
 3347   3510   
(
 3348   3511   
                                request_specs::constrained_http_payload_bound_shape_operation(),
 3349   3512   
                                self.constrained_http_payload_bound_shape_operation.unwrap_or_else(|| {
 3350   3513   
                                    let svc = ::aws_smithy_http_server::operation::MissingFailure::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::default();
 3351   3514   
                                    ::aws_smithy_http_server::routing::Route::new(svc)
 3352   3515   
                                })
 3353   3516   
                            ),
        3517  +
(
        3518  +
                                request_specs::constrained_list_with_indirectly_constrained_aggregate_operation(),
        3519  +
                                self.constrained_list_with_indirectly_constrained_aggregate_operation.unwrap_or_else(|| {
        3520  +
                                    let svc = ::aws_smithy_http_server::operation::MissingFailure::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::default();
        3521  +
                                    ::aws_smithy_http_server::routing::Route::new(svc)
        3522  +
                                })
        3523  +
                            ),
 3354   3524   
(
 3355   3525   
                                request_specs::constrained_recursive_shapes_operation(),
 3356   3526   
                                self.constrained_recursive_shapes_operation.unwrap_or_else(|| {
 3357   3527   
                                    let svc = ::aws_smithy_http_server::operation::MissingFailure::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::default();
 3358   3528   
                                    ::aws_smithy_http_server::routing::Route::new(svc)
 3359   3529   
                                })
 3360   3530   
                            ),
 3361   3531   
(
 3362   3532   
                                request_specs::constrained_shapes_only_in_output_operation(),
 3363   3533   
                                self.constrained_shapes_only_in_output_operation.unwrap_or_else(|| {
@@ -3520,3690 +3579,3764 @@
 3540   3710   
    pub(super) fn constrained_http_payload_bound_shape_operation(
 3541   3711   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
 3542   3712   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
 3543   3713   
                    ::http::Method::POST,
 3544   3714   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
 3545   3715   
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
 3546   3716   
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
 3547   3717   
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("constrained-http-payload-bound-shape-operation")),
 3548   3718   
]),
 3549   3719   
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
        3720  +
])
        3721  +
                        )
        3722  +
                    ),
        3723  +
                )
        3724  +
    }
        3725  +
    pub(super) fn constrained_list_with_indirectly_constrained_aggregate_operation(
        3726  +
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
        3727  +
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
        3728  +
                    ::http::Method::POST,
        3729  +
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
        3730  +
                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(
        3731  +
                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![
        3732  +
    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("constrained-list-with-indirectly-constrained-aggregate")),
        3733  +
]),
        3734  +
                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![
 3550   3735   
])
 3551   3736   
                        )
 3552   3737   
                    ),
 3553   3738   
                )
 3554   3739   
    }
 3555   3740   
    pub(super) fn constrained_recursive_shapes_operation(
 3556   3741   
    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {
 3557   3742   
        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(
 3558   3743   
                    ::http::Method::POST,
 3559   3744   
                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(
@@ -3828,4013 +3934,4121 @@
 3848   4033   
        Body,
 3849   4034   
        L,
 3850   4035   
        HttpPl: ::aws_smithy_http_server::plugin::HttpMarker,
 3851   4036   
        ModelPl: ::aws_smithy_http_server::plugin::ModelMarker,
 3852   4037   
    >(
 3853   4038   
        config: ConstraintsServiceConfig<L, HttpPl, ModelPl>,
 3854   4039   
    ) -> ConstraintsServiceBuilder<Body, L, HttpPl, ModelPl> {
 3855   4040   
        ConstraintsServiceBuilder {
 3856   4041   
            constrained_http_bound_shapes_operation: None,
 3857   4042   
            constrained_http_payload_bound_shape_operation: None,
        4043  +
            constrained_list_with_indirectly_constrained_aggregate_operation: None,
 3858   4044   
            constrained_recursive_shapes_operation: None,
 3859   4045   
            constrained_shapes_only_in_output_operation: None,
 3860   4046   
            constrained_shapes_operation: None,
 3861   4047   
            event_streams_operation: None,
 3862   4048   
            http_prefix_headers_targeting_length_map_operation: None,
 3863   4049   
            non_streaming_blob_operation: None,
 3864   4050   
            query_params_targeting_length_map_operation: None,
 3865   4051   
            query_params_targeting_map_of_enum_string_operation: None,
 3866   4052   
            query_params_targeting_map_of_length_list_of_pattern_string_operation: None,
 3867   4053   
            query_params_targeting_map_of_length_pattern_string_operation: None,
 3868   4054   
            query_params_targeting_map_of_length_string_operation: None,
 3869   4055   
            query_params_targeting_map_of_list_of_enum_string_operation: None,
 3870   4056   
            query_params_targeting_map_of_list_of_length_pattern_string_operation: None,
 3871   4057   
            query_params_targeting_map_of_list_of_length_string_operation: None,
 3872   4058   
            query_params_targeting_map_of_list_of_pattern_string_operation: None,
 3873   4059   
            query_params_targeting_map_of_pattern_string_operation: None,
 3874   4060   
            query_params_targeting_map_of_set_of_length_string_operation: None,
 3875   4061   
            streaming_blob_operation: None,
 3876   4062   
            layer: config.layers,
 3877   4063   
            http_plugin: config.http_plugins,
 3878   4064   
            model_plugin: config.model_plugins,
 3879   4065   
        }
 3880   4066   
    }
 3881   4067   
 3882   4068   
    /// Constructs a builder for [`ConstraintsService`].
 3883   4069   
    /// You must specify what plugins should be applied to the operations in this service.
 3884   4070   
    ///
 3885   4071   
    /// Use [`ConstraintsService::builder_without_plugins`] if you don't need to apply plugins.
 3886   4072   
    ///
 3887   4073   
    /// Check out [`HttpPlugins`](::aws_smithy_http_server::plugin::HttpPlugins) and
 3888   4074   
    /// [`ModelPlugins`](::aws_smithy_http_server::plugin::ModelPlugins) if you need to apply
 3889   4075   
    /// multiple plugins.
 3890   4076   
    #[deprecated(
 3891   4077   
        since = "0.57.0",
 3892   4078   
        note = "please use the `builder` constructor and register plugins on the `ConstraintsServiceConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"
 3893   4079   
    )]
 3894   4080   
    pub fn builder_with_plugins<
 3895   4081   
        Body,
 3896   4082   
        HttpPl: ::aws_smithy_http_server::plugin::HttpMarker,
 3897   4083   
        ModelPl: ::aws_smithy_http_server::plugin::ModelMarker,
 3898   4084   
    >(
 3899   4085   
        http_plugin: HttpPl,
 3900   4086   
        model_plugin: ModelPl,
 3901   4087   
    ) -> ConstraintsServiceBuilder<Body, ::tower::layer::util::Identity, HttpPl, ModelPl> {
 3902   4088   
        ConstraintsServiceBuilder {
 3903   4089   
            constrained_http_bound_shapes_operation: None,
 3904   4090   
            constrained_http_payload_bound_shape_operation: None,
        4091  +
            constrained_list_with_indirectly_constrained_aggregate_operation: None,
 3905   4092   
            constrained_recursive_shapes_operation: None,
 3906   4093   
            constrained_shapes_only_in_output_operation: None,
 3907   4094   
            constrained_shapes_operation: None,
 3908   4095   
            event_streams_operation: None,
 3909   4096   
            http_prefix_headers_targeting_length_map_operation: None,
 3910   4097   
            non_streaming_blob_operation: None,
 3911   4098   
            query_params_targeting_length_map_operation: None,
 3912   4099   
            query_params_targeting_map_of_enum_string_operation: None,
 3913   4100   
            query_params_targeting_map_of_length_list_of_pattern_string_operation: None,
 3914   4101   
            query_params_targeting_map_of_length_pattern_string_operation: None,
@@ -4017,4204 +4137,4333 @@
 4037   4224   
        self.svc.call(request)
 4038   4225   
    }
 4039   4226   
}
 4040   4227   
 4041   4228   
/// An enumeration of all [operations](https://smithy.io/2.0/spec/service-types.html#operation) in ConstraintsService.
 4042   4229   
#[allow(clippy::enum_variant_names)]
 4043   4230   
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 4044   4231   
pub enum Operation {
 4045   4232   
    ConstrainedHttpBoundShapesOperation,
 4046   4233   
    ConstrainedHttpPayloadBoundShapeOperation,
        4234  +
    ConstrainedListWithIndirectlyConstrainedAggregateOperation,
 4047   4235   
    ConstrainedRecursiveShapesOperation,
 4048   4236   
    ConstrainedShapesOnlyInOutputOperation,
 4049   4237   
    ConstrainedShapesOperation,
 4050   4238   
    EventStreamsOperation,
 4051   4239   
    HttpPrefixHeadersTargetingLengthMapOperation,
 4052   4240   
    NonStreamingBlobOperation,
 4053   4241   
    QueryParamsTargetingLengthMapOperation,
 4054   4242   
    QueryParamsTargetingMapOfEnumStringOperation,
 4055   4243   
    QueryParamsTargetingMapOfLengthListOfPatternStringOperation,
 4056   4244   
    QueryParamsTargetingMapOfLengthPatternStringOperation,
 4057   4245   
    QueryParamsTargetingMapOfLengthStringOperation,
 4058   4246   
    QueryParamsTargetingMapOfListOfEnumStringOperation,
 4059   4247   
    QueryParamsTargetingMapOfListOfLengthPatternStringOperation,
 4060   4248   
    QueryParamsTargetingMapOfListOfLengthStringOperation,
 4061   4249   
    QueryParamsTargetingMapOfListOfPatternStringOperation,
 4062   4250   
    QueryParamsTargetingMapOfPatternStringOperation,
 4063   4251   
    QueryParamsTargetingMapOfSetOfLengthStringOperation,
 4064   4252   
    StreamingBlobOperation,
 4065   4253   
}
 4066   4254   
 4067   4255   
impl Operation {
 4068   4256   
    /// Returns the [operations](https://smithy.io/2.0/spec/service-types.html#operation) [`ShapeId`](::aws_smithy_http_server::shape_id::ShapeId).
 4069   4257   
    pub fn shape_id(&self) -> ::aws_smithy_http_server::shape_id::ShapeId {
 4070   4258   
        match self {
 4071   4259   
                            Operation::ConstrainedHttpBoundShapesOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#ConstrainedHttpBoundShapesOperation", "com.amazonaws.constraints", "ConstrainedHttpBoundShapesOperation")
 4072   4260   
,Operation::ConstrainedHttpPayloadBoundShapeOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#ConstrainedHttpPayloadBoundShapeOperation", "com.amazonaws.constraints", "ConstrainedHttpPayloadBoundShapeOperation")
        4261  +
,Operation::ConstrainedListWithIndirectlyConstrainedAggregateOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#ConstrainedListWithIndirectlyConstrainedAggregateOperation", "com.amazonaws.constraints", "ConstrainedListWithIndirectlyConstrainedAggregateOperation")
 4073   4262   
,Operation::ConstrainedRecursiveShapesOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#ConstrainedRecursiveShapesOperation", "com.amazonaws.constraints", "ConstrainedRecursiveShapesOperation")
 4074   4263   
,Operation::ConstrainedShapesOnlyInOutputOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#ConstrainedShapesOnlyInOutputOperation", "com.amazonaws.constraints", "ConstrainedShapesOnlyInOutputOperation")
 4075   4264   
,Operation::ConstrainedShapesOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#ConstrainedShapesOperation", "com.amazonaws.constraints", "ConstrainedShapesOperation")
 4076   4265   
,Operation::EventStreamsOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#EventStreamsOperation", "com.amazonaws.constraints", "EventStreamsOperation")
 4077   4266   
,Operation::HttpPrefixHeadersTargetingLengthMapOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#HttpPrefixHeadersTargetingLengthMapOperation", "com.amazonaws.constraints", "HttpPrefixHeadersTargetingLengthMapOperation")
 4078   4267   
,Operation::NonStreamingBlobOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#NonStreamingBlobOperation", "com.amazonaws.constraints", "NonStreamingBlobOperation")
 4079   4268   
,Operation::QueryParamsTargetingLengthMapOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingLengthMapOperation", "com.amazonaws.constraints", "QueryParamsTargetingLengthMapOperation")
 4080   4269   
,Operation::QueryParamsTargetingMapOfEnumStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfEnumStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfEnumStringOperation")
 4081   4270   
,Operation::QueryParamsTargetingMapOfLengthListOfPatternStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfLengthListOfPatternStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfLengthListOfPatternStringOperation")
 4082   4271   
,Operation::QueryParamsTargetingMapOfLengthPatternStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfLengthPatternStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfLengthPatternStringOperation")
 4083   4272   
,Operation::QueryParamsTargetingMapOfLengthStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfLengthStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfLengthStringOperation")
 4084   4273   
,Operation::QueryParamsTargetingMapOfListOfEnumStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfListOfEnumStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfListOfEnumStringOperation")
 4085   4274   
,Operation::QueryParamsTargetingMapOfListOfLengthPatternStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfListOfLengthPatternStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfListOfLengthPatternStringOperation")
 4086   4275   
,Operation::QueryParamsTargetingMapOfListOfLengthStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfListOfLengthStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfListOfLengthStringOperation")
 4087   4276   
,Operation::QueryParamsTargetingMapOfListOfPatternStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfListOfPatternStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfListOfPatternStringOperation")
 4088   4277   
,Operation::QueryParamsTargetingMapOfPatternStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfPatternStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfPatternStringOperation")
 4089   4278   
,Operation::QueryParamsTargetingMapOfSetOfLengthStringOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#QueryParamsTargetingMapOfSetOfLengthStringOperation", "com.amazonaws.constraints", "QueryParamsTargetingMapOfSetOfLengthStringOperation")
 4090   4279   
,Operation::StreamingBlobOperation => ::aws_smithy_http_server::shape_id::ShapeId::new("com.amazonaws.constraints#StreamingBlobOperation", "com.amazonaws.constraints", "StreamingBlobOperation")
 4091   4280   
                        }
 4092   4281   
    }
 4093   4282   
}
 4094   4283   
impl<L>
 4095   4284   
    ::aws_smithy_http_server::service::ContainsOperation<
 4096   4285   
        crate::operation_shape::ConstrainedHttpBoundShapesOperation,
 4097   4286   
    > for ConstraintsService<L>
 4098   4287   
{
 4099   4288   
    const VALUE: Operation = Operation::ConstrainedHttpBoundShapesOperation;
 4100   4289   
}
 4101   4290   
impl<L>
 4102   4291   
    ::aws_smithy_http_server::service::ContainsOperation<
 4103   4292   
        crate::operation_shape::ConstrainedHttpPayloadBoundShapeOperation,
 4104   4293   
    > for ConstraintsService<L>
 4105   4294   
{
 4106   4295   
    const VALUE: Operation = Operation::ConstrainedHttpPayloadBoundShapeOperation;
 4107   4296   
}
        4297  +
impl<L>
        4298  +
    ::aws_smithy_http_server::service::ContainsOperation<
        4299  +
        crate::operation_shape::ConstrainedListWithIndirectlyConstrainedAggregateOperation,
        4300  +
    > for ConstraintsService<L>
        4301  +
{
        4302  +
    const VALUE: Operation = Operation::ConstrainedListWithIndirectlyConstrainedAggregateOperation;
        4303  +
}
 4108   4304   
impl<L>
 4109   4305   
    ::aws_smithy_http_server::service::ContainsOperation<
 4110   4306   
        crate::operation_shape::ConstrainedRecursiveShapesOperation,
 4111   4307   
    > for ConstraintsService<L>
 4112   4308   
{
 4113   4309   
    const VALUE: Operation = Operation::ConstrainedRecursiveShapesOperation;
 4114   4310   
}
 4115   4311   
impl<L>
 4116   4312   
    ::aws_smithy_http_server::service::ContainsOperation<
 4117   4313   
        crate::operation_shape::ConstrainedShapesOnlyInOutputOperation,
@@ -4411,4607 +4470,4675 @@
 4431   4627   
 4432   4628   
                        // ConstrainedHttpPayloadBoundShapeOperation match found, pop from both `member` and `not_member`
 4433   4629   
                        (@ $ name: ident, $ contains: ident (ConstrainedHttpPayloadBoundShapeOperation $($ member: ident)*) ($($ temp: ident)*) (ConstrainedHttpPayloadBoundShapeOperation $($ not_member: ident)*)) => {
 4434   4630   
                            scope! { @ $ name, $ contains ($($ member)*) ($($ temp)*) ($($ not_member)*) }
 4435   4631   
                        };
 4436   4632   
                        // ConstrainedHttpPayloadBoundShapeOperation match not found, pop from `not_member` into `temp` stack
 4437   4633   
                        (@ $ name: ident, $ contains: ident (ConstrainedHttpPayloadBoundShapeOperation $($ member: ident)*) ($($ temp: ident)*) ($ other: ident $($ not_member: ident)*)) => {
 4438   4634   
                            scope! { @ $ name, $ contains (ConstrainedHttpPayloadBoundShapeOperation $($ member)*) ($ other $($ temp)*) ($($ not_member)*) }
 4439   4635   
                        };
 4440   4636   
        4637  +
                        // ConstrainedListWithIndirectlyConstrainedAggregateOperation match found, pop from both `member` and `not_member`
        4638  +
                        (@ $ name: ident, $ contains: ident (ConstrainedListWithIndirectlyConstrainedAggregateOperation $($ member: ident)*) ($($ temp: ident)*) (ConstrainedListWithIndirectlyConstrainedAggregateOperation $($ not_member: ident)*)) => {
        4639  +
                            scope! { @ $ name, $ contains ($($ member)*) ($($ temp)*) ($($ not_member)*) }
        4640  +
                        };
        4641  +
                        // ConstrainedListWithIndirectlyConstrainedAggregateOperation match not found, pop from `not_member` into `temp` stack
        4642  +
                        (@ $ name: ident, $ contains: ident (ConstrainedListWithIndirectlyConstrainedAggregateOperation $($ member: ident)*) ($($ temp: ident)*) ($ other: ident $($ not_member: ident)*)) => {
        4643  +
                            scope! { @ $ name, $ contains (ConstrainedListWithIndirectlyConstrainedAggregateOperation $($ member)*) ($ other $($ temp)*) ($($ not_member)*) }
        4644  +
                        };
        4645  +
 4441   4646   
                        // ConstrainedRecursiveShapesOperation match found, pop from both `member` and `not_member`
 4442   4647   
                        (@ $ name: ident, $ contains: ident (ConstrainedRecursiveShapesOperation $($ member: ident)*) ($($ temp: ident)*) (ConstrainedRecursiveShapesOperation $($ not_member: ident)*)) => {
 4443   4648   
                            scope! { @ $ name, $ contains ($($ member)*) ($($ temp)*) ($($ not_member)*) }
 4444   4649   
                        };
 4445   4650   
                        // ConstrainedRecursiveShapesOperation match not found, pop from `not_member` into `temp` stack
 4446   4651   
                        (@ $ name: ident, $ contains: ident (ConstrainedRecursiveShapesOperation $($ member: ident)*) ($($ temp: ident)*) ($ other: ident $($ not_member: ident)*)) => {
 4447   4652   
                            scope! { @ $ name, $ contains (ConstrainedRecursiveShapesOperation $($ member)*) ($ other $($ temp)*) ($($ not_member)*) }
 4448   4653   
                        };
 4449   4654   
 4450   4655   
                        // ConstrainedShapesOnlyInOutputOperation match found, pop from both `member` and `not_member`
@@ -4587,4792 +4636,4841 @@
 4607   4812   
                        }
 4608   4813   
                    ) => {
 4609   4814   
                        use $ crate::operation_shape::*;
 4610   4815   
                        $ crate::server::scope! {
 4611   4816   
                            $(#[$ attrs])*
 4612   4817   
                            $ vis struct $ name {
 4613   4818   
                                includes: [$($ include),*],
 4614   4819   
                                excludes: []
 4615   4820   
                            }
 4616   4821   
                        }
 4617         -
                        scope! { @ $ name, False ($($ include)*) () (ConstrainedHttpBoundShapesOperation ConstrainedHttpPayloadBoundShapeOperation ConstrainedRecursiveShapesOperation ConstrainedShapesOnlyInOutputOperation ConstrainedShapesOperation EventStreamsOperation HttpPrefixHeadersTargetingLengthMapOperation NonStreamingBlobOperation QueryParamsTargetingLengthMapOperation QueryParamsTargetingMapOfEnumStringOperation QueryParamsTargetingMapOfLengthListOfPatternStringOperation QueryParamsTargetingMapOfLengthPatternStringOperation QueryParamsTargetingMapOfLengthStringOperation QueryParamsTargetingMapOfListOfEnumStringOperation QueryParamsTargetingMapOfListOfLengthPatternStringOperation QueryParamsTargetingMapOfListOfLengthStringOperation QueryParamsTargetingMapOfListOfPatternStringOperation QueryParamsTargetingMapOfPatternStringOperation QueryParamsTargetingMapOfSetOfLengthStringOperation StreamingBlobOperation) }
        4822  +
                        scope! { @ $ name, False ($($ include)*) () (ConstrainedHttpBoundShapesOperation ConstrainedHttpPayloadBoundShapeOperation ConstrainedListWithIndirectlyConstrainedAggregateOperation ConstrainedRecursiveShapesOperation ConstrainedShapesOnlyInOutputOperation ConstrainedShapesOperation EventStreamsOperation HttpPrefixHeadersTargetingLengthMapOperation NonStreamingBlobOperation QueryParamsTargetingLengthMapOperation QueryParamsTargetingMapOfEnumStringOperation QueryParamsTargetingMapOfLengthListOfPatternStringOperation QueryParamsTargetingMapOfLengthPatternStringOperation QueryParamsTargetingMapOfLengthStringOperation QueryParamsTargetingMapOfListOfEnumStringOperation QueryParamsTargetingMapOfListOfLengthPatternStringOperation QueryParamsTargetingMapOfListOfLengthStringOperation QueryParamsTargetingMapOfListOfPatternStringOperation QueryParamsTargetingMapOfPatternStringOperation QueryParamsTargetingMapOfSetOfLengthStringOperation StreamingBlobOperation) }
 4618   4823   
                    };
 4619   4824   
                    (
 4620   4825   
                        $(#[$ attrs:meta])*
 4621   4826   
                        $ vis:vis struct $ name:ident {
 4622   4827   
                            excludes: [$($ exclude:ident),*]
 4623   4828   
                        }
 4624   4829   
                    ) => {
 4625   4830   
                        use $ crate::operation_shape::*;
 4626   4831   
 4627   4832   
                        $ crate::server::scope! {
 4628   4833   
                            $(#[$ attrs])*
 4629   4834   
                            $ vis struct $ name {
 4630   4835   
                                includes: [],
 4631   4836   
                                excludes: [$($ exclude),*]
 4632   4837   
                            }
 4633   4838   
                        }
 4634         -
                        scope! { @ $ name, True ($($ exclude)*) () (ConstrainedHttpBoundShapesOperation ConstrainedHttpPayloadBoundShapeOperation ConstrainedRecursiveShapesOperation ConstrainedShapesOnlyInOutputOperation ConstrainedShapesOperation EventStreamsOperation HttpPrefixHeadersTargetingLengthMapOperation NonStreamingBlobOperation QueryParamsTargetingLengthMapOperation QueryParamsTargetingMapOfEnumStringOperation QueryParamsTargetingMapOfLengthListOfPatternStringOperation QueryParamsTargetingMapOfLengthPatternStringOperation QueryParamsTargetingMapOfLengthStringOperation QueryParamsTargetingMapOfListOfEnumStringOperation QueryParamsTargetingMapOfListOfLengthPatternStringOperation QueryParamsTargetingMapOfListOfLengthStringOperation QueryParamsTargetingMapOfListOfPatternStringOperation QueryParamsTargetingMapOfPatternStringOperation QueryParamsTargetingMapOfSetOfLengthStringOperation StreamingBlobOperation) }
        4839  +
                        scope! { @ $ name, True ($($ exclude)*) () (ConstrainedHttpBoundShapesOperation ConstrainedHttpPayloadBoundShapeOperation ConstrainedListWithIndirectlyConstrainedAggregateOperation ConstrainedRecursiveShapesOperation ConstrainedShapesOnlyInOutputOperation ConstrainedShapesOperation EventStreamsOperation HttpPrefixHeadersTargetingLengthMapOperation NonStreamingBlobOperation QueryParamsTargetingLengthMapOperation QueryParamsTargetingMapOfEnumStringOperation QueryParamsTargetingMapOfLengthListOfPatternStringOperation QueryParamsTargetingMapOfLengthPatternStringOperation QueryParamsTargetingMapOfLengthStringOperation QueryParamsTargetingMapOfListOfEnumStringOperation QueryParamsTargetingMapOfListOfLengthPatternStringOperation QueryParamsTargetingMapOfListOfLengthStringOperation QueryParamsTargetingMapOfListOfPatternStringOperation QueryParamsTargetingMapOfPatternStringOperation QueryParamsTargetingMapOfSetOfLengthStringOperation StreamingBlobOperation) }
 4635   4840   
                    };
 4636   4841   
                }

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/unconstrained.rs

@@ -113,113 +173,175 @@
  133    133   
                        }
  134    134   
                    }
  135    135   
    impl std::convert::TryFrom<ListOfLengthPatternStringUnconstrained> for crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained {
  136    136   
        type Error = crate::model::list_of_length_pattern_string_internal::ConstraintViolation;
  137    137   
        fn try_from(value: ListOfLengthPatternStringUnconstrained) -> Result<Self, Self::Error> {
  138    138   
            let res: Result<::std::vec::Vec<crate::model::LengthPatternString>, (usize, crate::model::length_pattern_string_internal::ConstraintViolation) > = value
  139    139   
                                        .0
  140    140   
                                        .into_iter()
  141    141   
                                        .enumerate()
  142    142   
                                        .map(|(idx, inner)| {
  143         -
                                            inner.try_into().map_err(|inner_violation| (idx, inner_violation))
         143  +
                                            inner.try_into()
         144  +
                                                    
         145  +
                                                    .map_err(|inner_violation| (idx, inner_violation))
  144    146   
                                        })
  145    147   
                                        .collect();
  146    148   
                                    let inner = res
  147    149   
                                        
  148    150   
                                        .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
  149    151   
            Ok(Self(inner))
  150    152   
        }
  151    153   
    }
  152    154   
}
  153    155   
pub(crate) mod map_of_length_pattern_string_unconstrained {
@@ -602,604 +689,828 @@
  622    624   
                            Err(Self::Error::Value(k, inner_constraint_violation))
  623    625   
                        }
  624    626   
                    }
  625    627   
                })
  626    628   
                .collect();
  627    629   
            let hm = res?;
  628    630   
            Ok(Self(hm))
  629    631   
        }
  630    632   
    }
  631    633   
}
         634  +
pub(crate) mod list_with_indirectly_constrained_map_unconstrained {
         635  +
         636  +
    #[derive(Debug, Clone)]
         637  +
    pub(crate) struct ListWithIndirectlyConstrainedMapUnconstrained(pub(crate) std::vec::Vec<crate::unconstrained::indirectly_constrained_map_unconstrained::IndirectlyConstrainedMapUnconstrained>);
         638  +
         639  +
    impl From<ListWithIndirectlyConstrainedMapUnconstrained>
         640  +
        for crate::constrained::MaybeConstrained<crate::model::ListWithIndirectlyConstrainedMap>
         641  +
    {
         642  +
        fn from(value: ListWithIndirectlyConstrainedMapUnconstrained) -> Self {
         643  +
            Self::Unconstrained(value)
         644  +
        }
         645  +
    }
         646  +
    impl std::convert::TryFrom<ListWithIndirectlyConstrainedMapUnconstrained>
         647  +
        for crate::model::ListWithIndirectlyConstrainedMap
         648  +
    {
         649  +
        type Error =
         650  +
            crate::model::list_with_indirectly_constrained_map_internal::ConstraintViolation;
         651  +
        fn try_from(
         652  +
            value: ListWithIndirectlyConstrainedMapUnconstrained,
         653  +
        ) -> Result<Self, Self::Error> {
         654  +
            let res: Result<::std::vec::Vec<::std::collections::HashMap::<crate::model::LengthString, crate::model::LengthString>>, (usize, crate::model::indirectly_constrained_map_internal::ConstraintViolation) > = value
         655  +
                                        .0
         656  +
                                        .into_iter()
         657  +
                                        .enumerate()
         658  +
                                        .map(|(idx, inner)| {
         659  +
                                            inner.try_into()
         660  +
                                                    .map(|c : crate::constrained::indirectly_constrained_map_constrained::IndirectlyConstrainedMapConstrained| c.into())
         661  +
                                                    .map_err(|inner_violation| (idx, inner_violation))
         662  +
                                        })
         663  +
                                        .collect();
         664  +
            let inner =
         665  +
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         666  +
            Self::try_from(inner)
         667  +
        }
         668  +
    }
         669  +
}
         670  +
pub(crate) mod indirectly_constrained_map_unconstrained {
         671  +
         672  +
    #[derive(Debug, Clone)]
         673  +
    pub(crate) struct IndirectlyConstrainedMapUnconstrained(
         674  +
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
         675  +
    );
         676  +
         677  +
    impl From<IndirectlyConstrainedMapUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::indirectly_constrained_map_constrained::IndirectlyConstrainedMapConstrained> {
         678  +
                        fn from(value: IndirectlyConstrainedMapUnconstrained) -> Self {
         679  +
                            Self::Unconstrained(value)
         680  +
                        }
         681  +
                    }
         682  +
    impl std::convert::TryFrom<IndirectlyConstrainedMapUnconstrained> for crate::constrained::indirectly_constrained_map_constrained::IndirectlyConstrainedMapConstrained {
         683  +
        type Error = crate::model::indirectly_constrained_map_internal::ConstraintViolation;
         684  +
        fn try_from(value: IndirectlyConstrainedMapUnconstrained) -> Result<Self, Self::Error> {
         685  +
            let res: Result<::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>, Self::Error> = value.0
         686  +
                                        .into_iter()
         687  +
                                        .map(|(k, v)| {
         688  +
                                            let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
         689  +
            
         690  +
            match crate::model::LengthString::try_from(v) {
         691  +
                                                    Ok(v) => Ok((k, v)),
         692  +
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
         693  +
                                                }
         694  +
                                        })
         695  +
                                        .collect();
         696  +
                                    let hm = res?;
         697  +
            Ok(Self(hm))
         698  +
        }
         699  +
    }
         700  +
}
         701  +
pub(crate) mod list_with_indirectly_constrained_list_unconstrained {
         702  +
         703  +
    #[derive(Debug, Clone)]
         704  +
    pub(crate) struct ListWithIndirectlyConstrainedListUnconstrained(pub(crate) std::vec::Vec<crate::unconstrained::indirectly_constrained_list_unconstrained::IndirectlyConstrainedListUnconstrained>);
         705  +
         706  +
    impl From<ListWithIndirectlyConstrainedListUnconstrained>
         707  +
        for crate::constrained::MaybeConstrained<crate::model::ListWithIndirectlyConstrainedList>
         708  +
    {
         709  +
        fn from(value: ListWithIndirectlyConstrainedListUnconstrained) -> Self {
         710  +
            Self::Unconstrained(value)
         711  +
        }
         712  +
    }
         713  +
    impl std::convert::TryFrom<ListWithIndirectlyConstrainedListUnconstrained>
         714  +
        for crate::model::ListWithIndirectlyConstrainedList
         715  +
    {
         716  +
        type Error =
         717  +
            crate::model::list_with_indirectly_constrained_list_internal::ConstraintViolation;
         718  +
        fn try_from(
         719  +
            value: ListWithIndirectlyConstrainedListUnconstrained,
         720  +
        ) -> Result<Self, Self::Error> {
         721  +
            let res: Result<::std::vec::Vec<::std::vec::Vec::<crate::model::LengthString>>, (usize, crate::model::indirectly_constrained_list_internal::ConstraintViolation) > = value
         722  +
                                        .0
         723  +
                                        .into_iter()
         724  +
                                        .enumerate()
         725  +
                                        .map(|(idx, inner)| {
         726  +
                                            inner.try_into()
         727  +
                                                    .map(|c : crate::constrained::indirectly_constrained_list_constrained::IndirectlyConstrainedListConstrained| c.into())
         728  +
                                                    .map_err(|inner_violation| (idx, inner_violation))
         729  +
                                        })
         730  +
                                        .collect();
         731  +
            let inner =
         732  +
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         733  +
            Self::try_from(inner)
         734  +
        }
         735  +
    }
         736  +
}
         737  +
pub(crate) mod indirectly_constrained_list_unconstrained {
         738  +
         739  +
    #[derive(Debug, Clone)]
         740  +
    pub(crate) struct IndirectlyConstrainedListUnconstrained(
         741  +
        pub(crate) std::vec::Vec<::std::string::String>,
         742  +
    );
         743  +
         744  +
    impl From<IndirectlyConstrainedListUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::indirectly_constrained_list_constrained::IndirectlyConstrainedListConstrained> {
         745  +
                        fn from(value: IndirectlyConstrainedListUnconstrained) -> Self {
         746  +
                            Self::Unconstrained(value)
         747  +
                        }
         748  +
                    }
         749  +
    impl std::convert::TryFrom<IndirectlyConstrainedListUnconstrained> for crate::constrained::indirectly_constrained_list_constrained::IndirectlyConstrainedListConstrained {
         750  +
        type Error = crate::model::indirectly_constrained_list_internal::ConstraintViolation;
         751  +
        fn try_from(value: IndirectlyConstrainedListUnconstrained) -> Result<Self, Self::Error> {
         752  +
            let res: Result<::std::vec::Vec<crate::model::LengthString>, (usize, crate::model::length_string_internal::ConstraintViolation) > = value
         753  +
                                        .0
         754  +
                                        .into_iter()
         755  +
                                        .enumerate()
         756  +
                                        .map(|(idx, inner)| {
         757  +
                                            inner.try_into()
         758  +
                                                    
         759  +
                                                    .map_err(|inner_violation| (idx, inner_violation))
         760  +
                                        })
         761  +
                                        .collect();
         762  +
                                    let inner = res
         763  +
                                        
         764  +
                                        .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         765  +
            Ok(Self(inner))
         766  +
        }
         767  +
    }
         768  +
}
  632    769   
pub(crate) mod recursive_list_unconstrained {
  633    770   
  634    771   
    #[derive(Debug, Clone)]
  635    772   
    pub(crate) struct RecursiveListUnconstrained(
  636    773   
        pub(crate) 
  637    774   
            std::vec::Vec<crate::model::recursive_shapes_input_output_nested1_internal::Builder>,
  638    775   
    );
  639    776   
  640    777   
    impl From<RecursiveListUnconstrained>
  641    778   
        for crate::constrained::MaybeConstrained<
  642    779   
            crate::constrained::recursive_list_constrained::RecursiveListConstrained,
  643    780   
        >
  644    781   
    {
  645    782   
        fn from(value: RecursiveListUnconstrained) -> Self {
  646    783   
            Self::Unconstrained(value)
  647    784   
        }
  648    785   
    }
  649    786   
    impl std::convert::TryFrom<RecursiveListUnconstrained>
  650    787   
        for crate::constrained::recursive_list_constrained::RecursiveListConstrained
  651    788   
    {
  652    789   
        type Error = crate::model::recursive_list_internal::ConstraintViolation;
  653    790   
        fn try_from(value: RecursiveListUnconstrained) -> Result<Self, Self::Error> {
  654    791   
            let res: Result<::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>, (usize, crate::model::recursive_shapes_input_output_nested1_internal::ConstraintViolation) > = value
  655    792   
                                        .0
  656    793   
                                        .into_iter()
  657    794   
                                        .enumerate()
  658    795   
                                        .map(|(idx, inner)| {
  659         -
                                            inner.try_into().map_err(|inner_violation| (idx, inner_violation))
         796  +
                                            inner.try_into()
         797  +
                                                    
         798  +
                                                    .map_err(|inner_violation| (idx, inner_violation))
  660    799   
                                        })
  661    800   
                                        .collect();
  662    801   
            let inner =
  663    802   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
  664    803   
            Ok(Self(inner))
  665    804   
        }
  666    805   
    }
  667    806   
}
  668    807   
pub(crate) mod length_set_of_pattern_string_unconstrained {
  669    808

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

@@ -159,159 +276,274 @@
  179    179   
  180    180   
    /// Serializes null values in maps
  181    181   
    /// Test ID: RpcV2CborSparseMapsSerializeNullValues
  182    182   
    #[::tokio::test]
  183    183   
    #[::tracing_test::traced_test]
  184    184   
    async fn rpc_v2_cbor_sparse_maps_serialize_null_values_request() {
  185    185   
        #[allow(unused_mut)]
  186    186   
        let mut http_request = http::Request::builder()
  187    187   
            .uri("/service/RpcV2Protocol/operation/SparseNullsOperation")
  188    188   
            .method("POST")
  189         -
            .header("Accept", "application/cbor")
  190    189   
            .header("Content-Type", "application/cbor")
  191    190   
            .header("smithy-protocol", "rpc-v2-cbor")
  192    191   
            .body(::aws_smithy_http_server::body::Body::from(
  193    192   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  194    193   
                    "v29zcGFyc2VTdHJpbmdNYXC/Y2Zvb/b//w==".as_bytes(),
  195    194   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  196    195   
                )),
  197    196   
            ))
  198    197   
            .unwrap();
  199    198   
        #[allow(unused_mut)]
  200    199   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
  201    200   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
  202    201   
        let service =
  203    202   
            crate::service::RpcV2Protocol::builder::<::hyper::body::Body, _, _, _>(config)
  204    203   
                .sparse_nulls_operation(move |input: crate::input::SparseNullsOperationInput| {
  205    204   
                    let sender = sender.clone();
  206    205   
                    async move {
  207    206   
                        let result = {
  208    207   
                            let expected = crate::input::SparseNullsOperationInput {
  209    208   
                                sparse_string_map: ::std::option::Option::Some({
  210    209   
                                    let mut ret = ::std::collections::HashMap::new();
  211    210   
                                    ret.insert("foo".to_owned(), ::std::option::Option::None);
  212    211   
                                    ret
  213    212   
                                }),
  214    213   
                                sparse_string_list: ::std::option::Option::None,
  215    214   
                            };
  216    215   
                            ::pretty_assertions::assert_eq!(input, expected);
  217    216   
                            let output = crate::output::SparseNullsOperationOutput {
  218    217   
                                sparse_string_list: ::std::option::Option::None,
  219    218   
                                sparse_string_map: ::std::option::Option::None,
  220    219   
                            };
  221    220   
                            output
  222    221   
                        };
  223    222   
                        sender.send(()).await.expect("receiver dropped early");
  224    223   
                        result
  225    224   
                    }
  226    225   
                })
  227    226   
                .build_unchecked();
  228    227   
        let http_response = ::tower::ServiceExt::oneshot(service, http_request)
  229    228   
            .await
  230    229   
            .expect("unable to make an HTTP request");
  231    230   
        assert!(
  232    231   
            receiver.recv().await.is_some(),
  233    232   
            "we expected operation handler to be invoked but it was not entered"
  234    233   
        );
  235    234   
    }
  236    235   
  237    236   
    /// Serializes null values in lists
  238    237   
    /// Test ID: RpcV2CborSparseListsSerializeNull
  239    238   
    #[::tokio::test]
  240    239   
    #[::tracing_test::traced_test]
  241    240   
    async fn rpc_v2_cbor_sparse_lists_serialize_null_request() {
  242    241   
        #[allow(unused_mut)]
  243    242   
        let mut http_request = http::Request::builder()
  244    243   
            .uri("/service/RpcV2Protocol/operation/SparseNullsOperation")
  245    244   
            .method("POST")
  246         -
            .header("Accept", "application/cbor")
  247    245   
            .header("Content-Type", "application/cbor")
  248    246   
            .header("smithy-protocol", "rpc-v2-cbor")
  249    247   
            .body(::aws_smithy_http_server::body::Body::from(
  250    248   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  251    249   
                    "v3BzcGFyc2VTdHJpbmdMaXN0n/b//w==".as_bytes(),
  252    250   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  253    251   
                )),
  254    252   
            ))
  255    253   
            .unwrap();
  256    254   
        #[allow(unused_mut)]
@@ -452,450 +512,509 @@
  472    470   
    /// Server populates default values when missing in request body.
  473    471   
    /// Test ID: RpcV2CborServerPopulatesDefaultsWhenMissingInRequestBody
  474    472   
    #[::tokio::test]
  475    473   
    #[::tracing_test::traced_test]
  476    474   
    #[should_panic]
  477    475   
    async fn rpc_v2_cbor_server_populates_defaults_when_missing_in_request_body_request() {
  478    476   
        #[allow(unused_mut)]
  479    477   
        let mut http_request = http::Request::builder()
  480    478   
            .uri("/service/RpcV2Protocol/operation/OperationWithDefaults")
  481    479   
            .method("POST")
  482         -
            .header("Accept", "application/cbor")
  483    480   
            .header("Content-Type", "application/cbor")
  484    481   
            .header("smithy-protocol", "rpc-v2-cbor")
  485    482   
            .body(::aws_smithy_http_server::body::Body::from(
  486    483   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  487    484   
                    "v2hkZWZhdWx0c6D/".as_bytes(),
  488    485   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  489    486   
                )),
  490    487   
            ))
  491    488   
            .unwrap();
  492    489   
        #[allow(unused_mut)]
@@ -1014,1011 +1074,1070 @@
 1034   1031   
 1035   1032   
    /// Serializes recursive structures
 1036   1033   
    /// Test ID: RpcV2CborRecursiveShapes
 1037   1034   
    #[::tokio::test]
 1038   1035   
    #[::tracing_test::traced_test]
 1039   1036   
    async fn rpc_v2_cbor_recursive_shapes_request() {
 1040   1037   
        #[allow(unused_mut)]
 1041   1038   
                    let mut http_request = http::Request::builder()
 1042   1039   
                        .uri("/service/RpcV2Protocol/operation/RecursiveShapes")
 1043   1040   
                        .method("POST")
 1044         -
        .header("Accept", "application/cbor")
 1045   1041   
        .header("Content-Type", "application/cbor")
 1046   1042   
        .header("smithy-protocol", "rpc-v2-cbor")
 1047   1043   
        .body(::aws_smithy_http_server::body::Body::from(
 1048   1044   
                                ::bytes::Bytes::copy_from_slice(
 1049   1045   
                                    &::aws_smithy_protocol_test::decode_body_data("v2ZuZXN0ZWS/Y2Zvb2RGb28xZm5lc3RlZL9jYmFyZEJhcjFvcmVjdXJzaXZlTWVtYmVyv2Nmb29kRm9vMmZuZXN0ZWS/Y2JhcmRCYXIy//////8=".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 1050   1046   
                                )
 1051   1047   
                                )).unwrap();
 1052   1048   
        #[allow(unused_mut)]
 1053   1049   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 1054   1050   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -1274,1270 +1334,1329 @@
 1294   1290   
 1295   1291   
    /// Serializes sparse maps
 1296   1292   
    /// Test ID: RpcV2CborSparseMaps
 1297   1293   
    #[::tokio::test]
 1298   1294   
    #[::tracing_test::traced_test]
 1299   1295   
    async fn rpc_v2_cbor_sparse_maps_request() {
 1300   1296   
        #[allow(unused_mut)]
 1301   1297   
        let mut http_request = http::Request::builder()
 1302   1298   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborSparseMaps")
 1303   1299   
            .method("POST")
 1304         -
            .header("Accept", "application/cbor")
 1305   1300   
            .header("Content-Type", "application/cbor")
 1306   1301   
            .header("smithy-protocol", "rpc-v2-cbor")
 1307   1302   
            .body(::aws_smithy_http_server::body::Body::from(
 1308   1303   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 1309   1304   
                    "v29zcGFyc2VTdHJ1Y3RNYXC/Y2Zvb79iaGlldGhlcmX/Y2Jher9iaGljYnll////".as_bytes(),
 1310   1305   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 1311   1306   
                )),
 1312   1307   
            ))
 1313   1308   
            .unwrap();
 1314   1309   
        #[allow(unused_mut)]
@@ -1348,1343 +1408,1402 @@
 1368   1363   
 1369   1364   
    /// Serializes null map values in sparse maps
 1370   1365   
    /// Test ID: RpcV2CborSerializesNullMapValues
 1371   1366   
    #[::tokio::test]
 1372   1367   
    #[::tracing_test::traced_test]
 1373   1368   
    async fn rpc_v2_cbor_serializes_null_map_values_request() {
 1374   1369   
        #[allow(unused_mut)]
 1375   1370   
                    let mut http_request = http::Request::builder()
 1376   1371   
                        .uri("/service/RpcV2Protocol/operation/RpcV2CborSparseMaps")
 1377   1372   
                        .method("POST")
 1378         -
        .header("Accept", "application/cbor")
 1379   1373   
        .header("Content-Type", "application/cbor")
 1380   1374   
        .header("smithy-protocol", "rpc-v2-cbor")
 1381   1375   
        .body(::aws_smithy_http_server::body::Body::from(
 1382   1376   
                                ::bytes::Bytes::copy_from_slice(
 1383   1377   
                                    &::aws_smithy_protocol_test::decode_body_data("v3BzcGFyc2VCb29sZWFuTWFwv2F49v9vc3BhcnNlTnVtYmVyTWFwv2F49v9vc3BhcnNlU3RyaW5nTWFwv2F49v9vc3BhcnNlU3RydWN0TWFwv2F49v//".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 1384   1378   
                                )
 1385   1379   
                                )).unwrap();
 1386   1380   
        #[allow(unused_mut)]
 1387   1381   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 1388   1382   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -1421,1415 +1481,1474 @@
 1441   1435   
 1442   1436   
    /// A request that contains a sparse map of sets
 1443   1437   
    /// Test ID: RpcV2CborSerializesSparseSetMap
 1444   1438   
    #[::tokio::test]
 1445   1439   
    #[::tracing_test::traced_test]
 1446   1440   
    async fn rpc_v2_cbor_serializes_sparse_set_map_request() {
 1447   1441   
        #[allow(unused_mut)]
 1448   1442   
        let mut http_request = http::Request::builder()
 1449   1443   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborSparseMaps")
 1450   1444   
            .method("POST")
 1451         -
            .header("Accept", "application/cbor")
 1452   1445   
            .header("Content-Type", "application/cbor")
 1453   1446   
            .header("smithy-protocol", "rpc-v2-cbor")
 1454   1447   
            .body(::aws_smithy_http_server::body::Body::from(
 1455   1448   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 1456   1449   
                    "v2xzcGFyc2VTZXRNYXC/YXif/2F5n2FhYWL///8=".as_bytes(),
 1457   1450   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 1458   1451   
                )),
 1459   1452   
            ))
 1460   1453   
            .unwrap();
 1461   1454   
        #[allow(unused_mut)]
@@ -1497,1490 +1557,1549 @@
 1517   1510   
 1518   1511   
    /// A request that contains a sparse map of sets.
 1519   1512   
    /// Test ID: RpcV2CborSerializesSparseSetMapAndRetainsNull
 1520   1513   
    #[::tokio::test]
 1521   1514   
    #[::tracing_test::traced_test]
 1522   1515   
    async fn rpc_v2_cbor_serializes_sparse_set_map_and_retains_null_request() {
 1523   1516   
        #[allow(unused_mut)]
 1524   1517   
        let mut http_request = http::Request::builder()
 1525   1518   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborSparseMaps")
 1526   1519   
            .method("POST")
 1527         -
            .header("Accept", "application/cbor")
 1528   1520   
            .header("Content-Type", "application/cbor")
 1529   1521   
            .header("smithy-protocol", "rpc-v2-cbor")
 1530   1522   
            .body(::aws_smithy_http_server::body::Body::from(
 1531   1523   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 1532   1524   
                    "v2xzcGFyc2VTZXRNYXC/YXif/2F5n2FhYWL/YXr2//8=".as_bytes(),
 1533   1525   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 1534   1526   
                )),
 1535   1527   
            ))
 1536   1528   
            .unwrap();
 1537   1529   
        #[allow(unused_mut)]
@@ -1574,1566 +1634,1625 @@
 1594   1586   
 1595   1587   
    /// Ensure that 0 and false are sent over the wire in all maps and lists
 1596   1588   
    /// Test ID: RpcV2CborSerializesZeroValuesInSparseMaps
 1597   1589   
    #[::tokio::test]
 1598   1590   
    #[::tracing_test::traced_test]
 1599   1591   
    async fn rpc_v2_cbor_serializes_zero_values_in_sparse_maps_request() {
 1600   1592   
        #[allow(unused_mut)]
 1601   1593   
        let mut http_request = http::Request::builder()
 1602   1594   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborSparseMaps")
 1603   1595   
            .method("POST")
 1604         -
            .header("Accept", "application/cbor")
 1605   1596   
            .header("Content-Type", "application/cbor")
 1606   1597   
            .header("smithy-protocol", "rpc-v2-cbor")
 1607   1598   
            .body(::aws_smithy_http_server::body::Body::from(
 1608   1599   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 1609   1600   
                    "v29zcGFyc2VOdW1iZXJNYXC/YXgA/3BzcGFyc2VCb29sZWFuTWFwv2F49P//".as_bytes(),
 1610   1601   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 1611   1602   
                )),
 1612   1603   
            ))
 1613   1604   
            .unwrap();
 1614   1605   
        #[allow(unused_mut)]
@@ -2003,1994 +2063,2053 @@
 2023   2014   
 2024   2015   
    /// Serializes maps
 2025   2016   
    /// Test ID: RpcV2CborMaps
 2026   2017   
    #[::tokio::test]
 2027   2018   
    #[::tracing_test::traced_test]
 2028   2019   
    async fn rpc_v2_cbor_maps_request() {
 2029   2020   
        #[allow(unused_mut)]
 2030   2021   
        let mut http_request = http::Request::builder()
 2031   2022   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborDenseMaps")
 2032   2023   
            .method("POST")
 2033         -
            .header("Accept", "application/cbor")
 2034   2024   
            .header("Content-Type", "application/cbor")
 2035   2025   
            .header("smithy-protocol", "rpc-v2-cbor")
 2036   2026   
            .body(::aws_smithy_http_server::body::Body::from(
 2037   2027   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 2038   2028   
                    "oW5kZW5zZVN0cnVjdE1hcKJjZm9voWJoaWV0aGVyZWNiYXqhYmhpY2J5ZQ==".as_bytes(),
 2039   2029   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 2040   2030   
                )),
 2041   2031   
            ))
 2042   2032   
            .unwrap();
 2043   2033   
        #[allow(unused_mut)]
@@ -2077,2067 +2137,2126 @@
 2097   2087   
 2098   2088   
    /// Ensure that 0 and false are sent over the wire in all maps and lists
 2099   2089   
    /// Test ID: RpcV2CborSerializesZeroValuesInMaps
 2100   2090   
    #[::tokio::test]
 2101   2091   
    #[::tracing_test::traced_test]
 2102   2092   
    async fn rpc_v2_cbor_serializes_zero_values_in_maps_request() {
 2103   2093   
        #[allow(unused_mut)]
 2104   2094   
        let mut http_request = http::Request::builder()
 2105   2095   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborDenseMaps")
 2106   2096   
            .method("POST")
 2107         -
            .header("Accept", "application/cbor")
 2108   2097   
            .header("Content-Type", "application/cbor")
 2109   2098   
            .header("smithy-protocol", "rpc-v2-cbor")
 2110   2099   
            .body(::aws_smithy_http_server::body::Body::from(
 2111   2100   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 2112   2101   
                    "om5kZW5zZU51bWJlck1hcKFheABvZGVuc2VCb29sZWFuTWFwoWF49A==".as_bytes(),
 2113   2102   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 2114   2103   
                )),
 2115   2104   
            ))
 2116   2105   
            .unwrap();
 2117   2106   
        #[allow(unused_mut)]
@@ -2144,2133 +2204,2192 @@
 2164   2153   
 2165   2154   
    /// A request that contains a dense map of sets.
 2166   2155   
    /// Test ID: RpcV2CborSerializesDenseSetMap
 2167   2156   
    #[::tokio::test]
 2168   2157   
    #[::tracing_test::traced_test]
 2169   2158   
    async fn rpc_v2_cbor_serializes_dense_set_map_request() {
 2170   2159   
        #[allow(unused_mut)]
 2171   2160   
        let mut http_request = http::Request::builder()
 2172   2161   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborDenseMaps")
 2173   2162   
            .method("POST")
 2174         -
            .header("Accept", "application/cbor")
 2175   2163   
            .header("Content-Type", "application/cbor")
 2176   2164   
            .header("smithy-protocol", "rpc-v2-cbor")
 2177   2165   
            .body(::aws_smithy_http_server::body::Body::from(
 2178   2166   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 2179   2167   
                    "oWtkZW5zZVNldE1hcKJheIBheYJhYWFi".as_bytes(),
 2180   2168   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 2181   2169   
                )),
 2182   2170   
            ))
 2183   2171   
            .unwrap();
 2184   2172   
        #[allow(unused_mut)]
@@ -2478,2466 +2538,2525 @@
 2498   2486   
 2499   2487   
    /// Serializes RpcV2 Cbor lists
 2500   2488   
    /// Test ID: RpcV2CborLists
 2501   2489   
    #[::tokio::test]
 2502   2490   
    #[::tracing_test::traced_test]
 2503   2491   
    async fn rpc_v2_cbor_lists_request() {
 2504   2492   
        #[allow(unused_mut)]
 2505   2493   
                    let mut http_request = http::Request::builder()
 2506   2494   
                        .uri("/service/RpcV2Protocol/operation/RpcV2CborLists")
 2507   2495   
                        .method("POST")
 2508         -
        .header("Accept", "application/cbor")
 2509   2496   
        .header("Content-Type", "application/cbor")
 2510   2497   
        .header("smithy-protocol", "rpc-v2-cbor")
 2511   2498   
        .body(::aws_smithy_http_server::body::Body::from(
 2512   2499   
                                ::bytes::Bytes::copy_from_slice(
 2513   2500   
                                    &::aws_smithy_protocol_test::decode_body_data("v2pzdHJpbmdMaXN0gmNmb29jYmFyaXN0cmluZ1NldIJjZm9vY2JhcmtpbnRlZ2VyTGlzdIIBAmtib29sZWFuTGlzdIL19G10aW1lc3RhbXBMaXN0gsH7QdTX+/OAAADB+0HU1/vzgAAAaGVudW1MaXN0gmNGb29hMGtpbnRFbnVtTGlzdIIBAnBuZXN0ZWRTdHJpbmdMaXN0goJjZm9vY2JhcoJjYmF6Y3F1eG1zdHJ1Y3R1cmVMaXN0gqJhYWExYWJhMqJhYWEzYWJhNGhibG9iTGlzdIJDZm9vQ2Jhcv8=".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 2514   2501   
                                )
 2515   2502   
                                )).unwrap();
 2516   2503   
        #[allow(unused_mut)]
 2517   2504   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 2518   2505   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -2580,2567 +2640,2626 @@
 2600   2587   
 2601   2588   
    /// Serializes empty JSON lists
 2602   2589   
    /// Test ID: RpcV2CborListsEmpty
 2603   2590   
    #[::tokio::test]
 2604   2591   
    #[::tracing_test::traced_test]
 2605   2592   
    async fn rpc_v2_cbor_lists_empty_request() {
 2606   2593   
        #[allow(unused_mut)]
 2607   2594   
        let mut http_request = http::Request::builder()
 2608   2595   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborLists")
 2609   2596   
            .method("POST")
 2610         -
            .header("Accept", "application/cbor")
 2611   2597   
            .header("Content-Type", "application/cbor")
 2612   2598   
            .header("smithy-protocol", "rpc-v2-cbor")
 2613   2599   
            .body(::aws_smithy_http_server::body::Body::from(
 2614   2600   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 2615   2601   
                    "v2pzdHJpbmdMaXN0n///".as_bytes(),
 2616   2602   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 2617   2603   
                )),
 2618   2604   
            ))
 2619   2605   
            .unwrap();
 2620   2606   
        #[allow(unused_mut)]
@@ -2649,2635 +2709,2694 @@
 2669   2655   
 2670   2656   
    /// Serializes empty JSON definite length lists
 2671   2657   
    /// Test ID: RpcV2CborListsEmptyUsingDefiniteLength
 2672   2658   
    #[::tokio::test]
 2673   2659   
    #[::tracing_test::traced_test]
 2674   2660   
    async fn rpc_v2_cbor_lists_empty_using_definite_length_request() {
 2675   2661   
        #[allow(unused_mut)]
 2676   2662   
        let mut http_request = http::Request::builder()
 2677   2663   
            .uri("/service/RpcV2Protocol/operation/RpcV2CborLists")
 2678   2664   
            .method("POST")
 2679         -
            .header("Accept", "application/cbor")
 2680   2665   
            .header("Content-Type", "application/cbor")
 2681   2666   
            .header("smithy-protocol", "rpc-v2-cbor")
 2682   2667   
            .body(::aws_smithy_http_server::body::Body::from(
 2683   2668   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 2684   2669   
                    "oWpzdHJpbmdMaXN0gA==".as_bytes(),
 2685   2670   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 2686   2671   
                )),
 2687   2672   
            ))
 2688   2673   
            .unwrap();
 2689   2674   
        #[allow(unused_mut)]
@@ -2718,2703 +2778,2762 @@
 2738   2723   
 2739   2724   
    /// Can deserialize indefinite length text strings inside an indefinite length list
 2740   2725   
    /// Test ID: RpcV2CborIndefiniteStringInsideIndefiniteList
 2741   2726   
    #[::tokio::test]
 2742   2727   
    #[::tracing_test::traced_test]
 2743   2728   
    async fn rpc_v2_cbor_indefinite_string_inside_indefinite_list_request() {
 2744   2729   
        #[allow(unused_mut)]
 2745   2730   
                    let mut http_request = http::Request::builder()
 2746   2731   
                        .uri("/service/RpcV2Protocol/operation/RpcV2CborLists")
 2747   2732   
                        .method("POST")
 2748         -
        .header("Accept", "application/cbor")
 2749   2733   
        .header("Content-Type", "application/cbor")
 2750   2734   
        .header("smithy-protocol", "rpc-v2-cbor")
 2751   2735   
        .body(::aws_smithy_http_server::body::Body::from(
 2752   2736   
                                ::bytes::Bytes::copy_from_slice(
 2753   2737   
                                    &::aws_smithy_protocol_test::decode_body_data("v2pzdHJpbmdMaXN0n394HUFuIGV4YW1wbGUgaW5kZWZpbml0ZSBzdHJpbmcsdyB3aGljaCB3aWxsIGJlIGNodW5rZWQsbiBvbiBlYWNoIGNvbW1h/394NUFub3RoZXIgZXhhbXBsZSBpbmRlZmluaXRlIHN0cmluZyB3aXRoIG9ubHkgb25lIGNodW5r/3ZUaGlzIGlzIGEgcGxhaW4gc3RyaW5n//8=".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 2754   2738   
                                )
 2755   2739   
                                )).unwrap();
 2756   2740   
        #[allow(unused_mut)]
 2757   2741   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 2758   2742   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -2791,2775 +2851,2834 @@
 2811   2795   
 2812   2796   
    /// Can deserialize indefinite length text strings inside a definite length list
 2813   2797   
    /// Test ID: RpcV2CborIndefiniteStringInsideDefiniteList
 2814   2798   
    #[::tokio::test]
 2815   2799   
    #[::tracing_test::traced_test]
 2816   2800   
    async fn rpc_v2_cbor_indefinite_string_inside_definite_list_request() {
 2817   2801   
        #[allow(unused_mut)]
 2818   2802   
                    let mut http_request = http::Request::builder()
 2819   2803   
                        .uri("/service/RpcV2Protocol/operation/RpcV2CborLists")
 2820   2804   
                        .method("POST")
 2821         -
        .header("Accept", "application/cbor")
 2822   2805   
        .header("Content-Type", "application/cbor")
 2823   2806   
        .header("smithy-protocol", "rpc-v2-cbor")
 2824   2807   
        .body(::aws_smithy_http_server::body::Body::from(
 2825   2808   
                                ::bytes::Bytes::copy_from_slice(
 2826   2809   
                                    &::aws_smithy_protocol_test::decode_body_data("oWpzdHJpbmdMaXN0g394HUFuIGV4YW1wbGUgaW5kZWZpbml0ZSBzdHJpbmcsdyB3aGljaCB3aWxsIGJlIGNodW5rZWQsbiBvbiBlYWNoIGNvbW1h/394NUFub3RoZXIgZXhhbXBsZSBpbmRlZmluaXRlIHN0cmluZyB3aXRoIG9ubHkgb25lIGNodW5r/3ZUaGlzIGlzIGEgcGxhaW4gc3RyaW5n".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 2827   2810   
                                )
 2828   2811   
                                )).unwrap();
 2829   2812   
        #[allow(unused_mut)]
 2830   2813   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 2831   2814   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -3064,3047 +3124,3106 @@
 3084   3067   
 3085   3068   
    /// Serializes simple scalar properties
 3086   3069   
    /// Test ID: RpcV2CborSimpleScalarProperties
 3087   3070   
    #[::tokio::test]
 3088   3071   
    #[::tracing_test::traced_test]
 3089   3072   
    async fn rpc_v2_cbor_simple_scalar_properties_request() {
 3090   3073   
        #[allow(unused_mut)]
 3091   3074   
                    let mut http_request = http::Request::builder()
 3092   3075   
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3093   3076   
                        .method("POST")
 3094         -
        .header("Accept", "application/cbor")
 3095   3077   
        .header("Content-Type", "application/cbor")
 3096   3078   
        .header("smithy-protocol", "rpc-v2-cbor")
 3097   3079   
        .body(::aws_smithy_http_server::body::Body::from(
 3098   3080   
                                ::bytes::Bytes::copy_from_slice(
 3099   3081   
                                    &::aws_smithy_protocol_test::decode_body_data("v2lieXRlVmFsdWUFa2RvdWJsZVZhbHVl+z/+OVgQYk3TcWZhbHNlQm9vbGVhblZhbHVl9GpmbG9hdFZhbHVl+kD0AABsaW50ZWdlclZhbHVlGQEAaWxvbmdWYWx1ZRkmkWpzaG9ydFZhbHVlGSaqa3N0cmluZ1ZhbHVlZnNpbXBsZXB0cnVlQm9vbGVhblZhbHVl9WlibG9iVmFsdWVDZm9v/w==".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 3100   3082   
                                )
 3101   3083   
                                )).unwrap();
 3102   3084   
        #[allow(unused_mut)]
 3103   3085   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 3104   3086   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -3189,3171 +3249,3230 @@
 3209   3191   
    /// encoded using a map with a definite length. The server should also be able to parse
 3210   3192   
    /// a key encoded using an indefinite length string.
 3211   3193   
    /// Test ID: RpcV2CborSimpleScalarPropertiesUsingIndefiniteLength
 3212   3194   
    #[::tokio::test]
 3213   3195   
    #[::tracing_test::traced_test]
 3214   3196   
    async fn rpc_v2_cbor_simple_scalar_properties_using_indefinite_length_request() {
 3215   3197   
        #[allow(unused_mut)]
 3216   3198   
                    let mut http_request = http::Request::builder()
 3217   3199   
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3218   3200   
                        .method("POST")
 3219         -
        .header("Accept", "application/cbor")
 3220   3201   
        .header("Content-Type", "application/cbor")
 3221   3202   
        .header("smithy-protocol", "rpc-v2-cbor")
 3222   3203   
        .body(::aws_smithy_http_server::body::Body::from(
 3223   3204   
                                ::bytes::Bytes::copy_from_slice(
 3224   3205   
                                    &::aws_smithy_protocol_test::decode_body_data("qmlieXRlVmFsdWUFf2Zkb3VibGVlVmFsdWX/+z/+OVgQYk3Tf2VmYWxzZWdCb29sZWFuZVZhbHVl//RqZmxvYXRWYWx1ZfpA9AAAbGludGVnZXJWYWx1ZRkBAGlsb25nVmFsdWUZJpFqc2hvcnRWYWx1ZRkmqn9mc3RyaW5nZVZhbHVl/2ZzaW1wbGVwdHJ1ZUJvb2xlYW5WYWx1ZfVpYmxvYlZhbHVlQ2Zvbw==".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 3225   3206   
                                )
 3226   3207   
                                )).unwrap();
 3227   3208   
        #[allow(unused_mut)]
 3228   3209   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 3229   3210   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -3312,3293 +3372,3352 @@
 3332   3313   
 3333   3314   
    /// RpcV2 Cbor should not deserialize null structure values
 3334   3315   
    /// Test ID: RpcV2CborServerDoesntDeSerializeNullStructureValues
 3335   3316   
    #[::tokio::test]
 3336   3317   
    #[::tracing_test::traced_test]
 3337   3318   
    async fn rpc_v2_cbor_server_doesnt_de_serialize_null_structure_values_request() {
 3338   3319   
        #[allow(unused_mut)]
 3339   3320   
        let mut http_request = http::Request::builder()
 3340   3321   
            .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3341   3322   
            .method("POST")
 3342         -
            .header("Accept", "application/cbor")
 3343   3323   
            .header("Content-Type", "application/cbor")
 3344   3324   
            .header("smithy-protocol", "rpc-v2-cbor")
 3345   3325   
            .body(::aws_smithy_http_server::body::Body::from(
 3346   3326   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 3347   3327   
                    "v2tzdHJpbmdWYWx1Zfb/".as_bytes(),
 3348   3328   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 3349   3329   
                )),
 3350   3330   
            ))
 3351   3331   
            .unwrap();
 3352   3332   
        #[allow(unused_mut)]
@@ -3435,3415 +3495,3474 @@
 3455   3435   
 3456   3436   
    /// Supports handling NaN float values.
 3457   3437   
    /// Test ID: RpcV2CborSupportsNaNFloatInputs
 3458   3438   
    #[::tokio::test]
 3459   3439   
    #[::tracing_test::traced_test]
 3460   3440   
    async fn rpc_v2_cbor_supports_na_n_float_inputs_request() {
 3461   3441   
        #[allow(unused_mut)]
 3462   3442   
        let mut http_request = http::Request::builder()
 3463   3443   
            .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3464   3444   
            .method("POST")
 3465         -
            .header("Accept", "application/cbor")
 3466   3445   
            .header("Content-Type", "application/cbor")
 3467   3446   
            .header("smithy-protocol", "rpc-v2-cbor")
 3468   3447   
            .body(::aws_smithy_http_server::body::Body::from(
 3469   3448   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 3470   3449   
                    "v2tkb3VibGVWYWx1Zft/+AAAAAAAAGpmbG9hdFZhbHVl+n/AAAD/".as_bytes(),
 3471   3450   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 3472   3451   
                )),
 3473   3452   
            ))
 3474   3453   
            .unwrap();
 3475   3454   
        #[allow(unused_mut)]
@@ -3567,3546 +3627,3605 @@
 3587   3566   
 3588   3567   
    /// Supports handling Infinity float values.
 3589   3568   
    /// Test ID: RpcV2CborSupportsInfinityFloatInputs
 3590   3569   
    #[::tokio::test]
 3591   3570   
    #[::tracing_test::traced_test]
 3592   3571   
    async fn rpc_v2_cbor_supports_infinity_float_inputs_request() {
 3593   3572   
        #[allow(unused_mut)]
 3594   3573   
        let mut http_request = http::Request::builder()
 3595   3574   
            .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3596   3575   
            .method("POST")
 3597         -
            .header("Accept", "application/cbor")
 3598   3576   
            .header("Content-Type", "application/cbor")
 3599   3577   
            .header("smithy-protocol", "rpc-v2-cbor")
 3600   3578   
            .body(::aws_smithy_http_server::body::Body::from(
 3601   3579   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 3602   3580   
                    "v2tkb3VibGVWYWx1Zft/8AAAAAAAAGpmbG9hdFZhbHVl+n+AAAD/".as_bytes(),
 3603   3581   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 3604   3582   
                )),
 3605   3583   
            ))
 3606   3584   
            .unwrap();
 3607   3585   
        #[allow(unused_mut)]
@@ -3699,3677 +3759,3736 @@
 3719   3697   
 3720   3698   
    /// Supports handling Infinity float values.
 3721   3699   
    /// Test ID: RpcV2CborSupportsNegativeInfinityFloatInputs
 3722   3700   
    #[::tokio::test]
 3723   3701   
    #[::tracing_test::traced_test]
 3724   3702   
    async fn rpc_v2_cbor_supports_negative_infinity_float_inputs_request() {
 3725   3703   
        #[allow(unused_mut)]
 3726   3704   
        let mut http_request = http::Request::builder()
 3727   3705   
            .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3728   3706   
            .method("POST")
 3729         -
            .header("Accept", "application/cbor")
 3730   3707   
            .header("Content-Type", "application/cbor")
 3731   3708   
            .header("smithy-protocol", "rpc-v2-cbor")
 3732   3709   
            .body(::aws_smithy_http_server::body::Body::from(
 3733   3710   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 3734   3711   
                    "v2tkb3VibGVWYWx1Zfv/8AAAAAAAAGpmbG9hdFZhbHVl+v+AAAD/".as_bytes(),
 3735   3712   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 3736   3713   
                )),
 3737   3714   
            ))
 3738   3715   
            .unwrap();
 3739   3716   
        #[allow(unused_mut)]
@@ -3831,3808 +3891,3867 @@
 3851   3828   
 3852   3829   
    /// The server should be capable of deserializing indefinite length text strings.
 3853   3830   
    /// Test ID: RpcV2CborIndefiniteLengthStringsCanBeDeserialized
 3854   3831   
    #[::tokio::test]
 3855   3832   
    #[::tracing_test::traced_test]
 3856   3833   
    async fn rpc_v2_cbor_indefinite_length_strings_can_be_deserialized_request() {
 3857   3834   
        #[allow(unused_mut)]
 3858   3835   
                    let mut http_request = http::Request::builder()
 3859   3836   
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3860   3837   
                        .method("POST")
 3861         -
        .header("Accept", "application/cbor")
 3862   3838   
        .header("Content-Type", "application/cbor")
 3863   3839   
        .header("smithy-protocol", "rpc-v2-cbor")
 3864   3840   
        .body(::aws_smithy_http_server::body::Body::from(
 3865   3841   
                                ::bytes::Bytes::copy_from_slice(
 3866   3842   
                                    &::aws_smithy_protocol_test::decode_body_data("oWtzdHJpbmdWYWx1ZX94HUFuIGV4YW1wbGUgaW5kZWZpbml0ZSBzdHJpbmcscSBjaHVua2VkIG9uIGNvbW1h/w==".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 3867   3843   
                                )
 3868   3844   
                                )).unwrap();
 3869   3845   
        #[allow(unused_mut)]
 3870   3846   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 3871   3847   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -3954,3930 +4014,3989 @@
 3974   3950   
 3975   3951   
    /// The server should be capable of deserializing indefinite length byte strings.
 3976   3952   
    /// Test ID: RpcV2CborIndefiniteLengthByteStringsCanBeDeserialized
 3977   3953   
    #[::tokio::test]
 3978   3954   
    #[::tracing_test::traced_test]
 3979   3955   
    async fn rpc_v2_cbor_indefinite_length_byte_strings_can_be_deserialized_request() {
 3980   3956   
        #[allow(unused_mut)]
 3981   3957   
                    let mut http_request = http::Request::builder()
 3982   3958   
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 3983   3959   
                        .method("POST")
 3984         -
        .header("Accept", "application/cbor")
 3985   3960   
        .header("Content-Type", "application/cbor")
 3986   3961   
        .header("smithy-protocol", "rpc-v2-cbor")
 3987   3962   
        .body(::aws_smithy_http_server::body::Body::from(
 3988   3963   
                                ::bytes::Bytes::copy_from_slice(
 3989   3964   
                                    &::aws_smithy_protocol_test::decode_body_data("oWlibG9iVmFsdWVfWCJBbiBleGFtcGxlIGluZGVmaW5pdGUtYnl0ZSBzdHJpbmcsUSBjaHVua2VkIG9uIGNvbW1h/w==".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 3990   3965   
                                )
 3991   3966   
                                )).unwrap();
 3992   3967   
        #[allow(unused_mut)]
 3993   3968   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 3994   3969   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -4079,4054 +4139,4113 @@
 4099   4074   
 4100   4075   
    /// Supports upcasting from a smaller byte representation of the same data type.
 4101   4076   
    /// Test ID: RpcV2CborSupportsUpcastingData
 4102   4077   
    #[::tokio::test]
 4103   4078   
    #[::tracing_test::traced_test]
 4104   4079   
    async fn rpc_v2_cbor_supports_upcasting_data_request() {
 4105   4080   
        #[allow(unused_mut)]
 4106   4081   
                    let mut http_request = http::Request::builder()
 4107   4082   
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 4108   4083   
                        .method("POST")
 4109         -
        .header("Accept", "application/cbor")
 4110   4084   
        .header("Content-Type", "application/cbor")
 4111   4085   
        .header("smithy-protocol", "rpc-v2-cbor")
 4112   4086   
        .body(::aws_smithy_http_server::body::Body::from(
 4113   4087   
                                ::bytes::Bytes::copy_from_slice(
 4114   4088   
                                    &::aws_smithy_protocol_test::decode_body_data("v2tkb3VibGVWYWx1Zfk+AGpmbG9hdFZhbHVl+UegbGludGVnZXJWYWx1ZRg4aWxvbmdWYWx1ZRkBAGpzaG9ydFZhbHVlCv8=".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 4115   4089   
                                )
 4116   4090   
                                )).unwrap();
 4117   4091   
        #[allow(unused_mut)]
 4118   4092   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 4119   4093   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -4202,4176 +4262,4235 @@
 4222   4196   
    /// client generated against a newer Smithy model to be able to communicate with a server that is
 4223   4197   
    /// generated against an older Smithy model.
 4224   4198   
    /// Test ID: RpcV2CborExtraFieldsInTheBodyShouldBeSkippedByServers
 4225   4199   
    #[::tokio::test]
 4226   4200   
    #[::tracing_test::traced_test]
 4227   4201   
    async fn rpc_v2_cbor_extra_fields_in_the_body_should_be_skipped_by_servers_request() {
 4228   4202   
        #[allow(unused_mut)]
 4229   4203   
                    let mut http_request = http::Request::builder()
 4230   4204   
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 4231   4205   
                        .method("POST")
 4232         -
        .header("Accept", "application/cbor")
 4233   4206   
        .header("Content-Type", "application/cbor")
 4234   4207   
        .header("smithy-protocol", "rpc-v2-cbor")
 4235   4208   
        .body(::aws_smithy_http_server::body::Body::from(
 4236   4209   
                                ::bytes::Bytes::copy_from_slice(
 4237   4210   
                                    &::aws_smithy_protocol_test::decode_body_data("v2lieXRlVmFsdWUFa2RvdWJsZVZhbHVl+z/+OVgQYk3TcWZhbHNlQm9vbGVhblZhbHVl9GpmbG9hdFZhbHVl+kD0AABrZXh0cmFPYmplY3S/c2luZGVmaW5pdGVMZW5ndGhNYXC/a3dpdGhBbkFycmF5nwECA///cWRlZmluaXRlTGVuZ3RoTWFwo3J3aXRoQURlZmluaXRlQXJyYXmDAQIDeB1hbmRTb21lSW5kZWZpbml0ZUxlbmd0aFN0cmluZ3gfdGhhdCBoYXMsIGJlZW4gY2h1bmtlZCBvbiBjb21tYWxub3JtYWxTdHJpbmdjZm9vanNob3J0VmFsdWUZJw9uc29tZU90aGVyRmllbGR2dGhpcyBzaG91bGQgYmUgc2tpcHBlZP9saW50ZWdlclZhbHVlGQEAaWxvbmdWYWx1ZRkmkWpzaG9ydFZhbHVlGSaqa3N0cmluZ1ZhbHVlZnNpbXBsZXB0cnVlQm9vbGVhblZhbHVl9WlibG9iVmFsdWVDZm9v/w==".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 4238   4211   
                                )
 4239   4212   
                                )).unwrap();
 4240   4213   
        #[allow(unused_mut)]
 4241   4214   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 4242   4215   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
@@ -4316,4289 +4497,4348 @@
 4336   4309   
                .build_unchecked();
 4337   4310   
        let http_response = ::tower::ServiceExt::oneshot(service, http_request)
 4338   4311   
            .await
 4339   4312   
            .expect("unable to make an HTTP request");
 4340   4313   
        assert!(
 4341   4314   
            receiver.recv().await.is_some(),
 4342   4315   
            "we expected operation handler to be invoked but it was not entered"
 4343   4316   
        );
 4344   4317   
    }
 4345   4318   
 4346         -
    /// Servers should tolerate requests without an Accept header set.
 4347         -
    /// Test ID: RpcV2CborServersShouldHandleNoAcceptHeader
 4348         -
    #[::tokio::test]
 4349         -
    #[::tracing_test::traced_test]
 4350         -
    async fn rpc_v2_cbor_servers_should_handle_no_accept_header_request() {
 4351         -
        #[allow(unused_mut)]
 4352         -
                    let mut http_request = http::Request::builder()
 4353         -
                        .uri("/service/RpcV2Protocol/operation/SimpleScalarProperties")
 4354         -
                        .method("POST")
 4355         -
        .header("Content-Type", "application/cbor")
 4356         -
        .header("smithy-protocol", "rpc-v2-cbor")
 4357         -
        .body(::aws_smithy_http_server::body::Body::from(
 4358         -
                                ::bytes::Bytes::copy_from_slice(
 4359         -
                                    &::aws_smithy_protocol_test::decode_body_data("v2lieXRlVmFsdWUFa2RvdWJsZVZhbHVl+z/+OVgQYk3TcWZhbHNlQm9vbGVhblZhbHVl9GpmbG9hdFZhbHVl+kD0AABsaW50ZWdlclZhbHVlGQEAaWxvbmdWYWx1ZRkmkWpzaG9ydFZhbHVlGSaqa3N0cmluZ1ZhbHVlZnNpbXBsZXB0cnVlQm9vbGVhblZhbHVl9WlibG9iVmFsdWVDZm9v/w==".as_bytes(), ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
 4360         -
                                )
 4361         -
                                )).unwrap();
 4362         -
        #[allow(unused_mut)]
 4363         -
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 4364         -
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
 4365         -
        let service =
 4366         -
            crate::service::RpcV2Protocol::builder::<::hyper::body::Body, _, _, _>(config)
 4367         -
                .simple_scalar_properties(
 4368         -
                    move |input: crate::input::SimpleScalarPropertiesInput| {
 4369         -
                        let sender = sender.clone();
 4370         -
                        async move {
 4371         -
                            let result = {
 4372         -
                                use ::aws_smithy_protocol_test::FloatEquals;
 4373         -
                                let expected = crate::input::SimpleScalarPropertiesInput {
 4374         -
                                    byte_value: ::std::option::Option::Some(5),
 4375         -
                                    double_value: ::std::option::Option::Some(1.889_f64),
 4376         -
                                    false_boolean_value: ::std::option::Option::Some(false),
 4377         -
                                    float_value: ::std::option::Option::Some(7.625_f32),
 4378         -
                                    integer_value: ::std::option::Option::Some(256),
 4379         -
                                    long_value: ::std::option::Option::Some(9873),
 4380         -
                                    short_value: ::std::option::Option::Some(9898),
 4381         -
                                    string_value: ::std::option::Option::Some("simple".to_owned()),
 4382         -
                                    true_boolean_value: ::std::option::Option::Some(true),
 4383         -
                                    blob_value: ::std::option::Option::Some(
 4384         -
                                        ::aws_smithy_types::Blob::new("foo"),
 4385         -
                                    ),
 4386         -
                                };
 4387         -
                                ::pretty_assertions::assert_eq!(
 4388         -
                                    input.true_boolean_value,
 4389         -
                                    expected.true_boolean_value,
 4390         -
                                    "Unexpected value for `true_boolean_value`"
 4391         -
                                );
 4392         -
                                ::pretty_assertions::assert_eq!(
 4393         -
                                    input.false_boolean_value,
 4394         -
                                    expected.false_boolean_value,
 4395         -
                                    "Unexpected value for `false_boolean_value`"
 4396         -
                                );
 4397         -
                                ::pretty_assertions::assert_eq!(
 4398         -
                                    input.byte_value,
 4399         -
                                    expected.byte_value,
 4400         -
                                    "Unexpected value for `byte_value`"
 4401         -
                                );
 4402         -
                                assert!(
 4403         -
                                    input.double_value.float_equals(&expected.double_value),
 4404         -
                                    "Unexpected value for `double_value` {:?} vs. {:?}",
 4405         -
                                    expected.double_value,
 4406         -
                                    input.double_value
 4407         -
                                );
 4408         -
                                assert!(
 4409         -
                                    input.float_value.float_equals(&expected.float_value),
 4410         -
                                    "Unexpected value for `float_value` {:?} vs. {:?}",
 4411         -
                                    expected.float_value,
 4412         -
                                    input.float_value
 4413         -
                                );
 4414         -
                                ::pretty_assertions::assert_eq!(
 4415         -
                                    input.integer_value,
 4416         -
                                    expected.integer_value,
 4417         -
                                    "Unexpected value for `integer_value`"
 4418         -
                                );
 4419         -
                                ::pretty_assertions::assert_eq!(
 4420         -
                                    input.long_value,
 4421         -
                                    expected.long_value,
 4422         -
                                    "Unexpected value for `long_value`"
 4423         -
                                );
 4424         -
                                ::pretty_assertions::assert_eq!(
 4425         -
                                    input.short_value,
 4426         -
                                    expected.short_value,
 4427         -
                                    "Unexpected value for `short_value`"
 4428         -
                                );
 4429         -
                                ::pretty_assertions::assert_eq!(
 4430         -
                                    input.string_value,
 4431         -
                                    expected.string_value,
 4432         -
                                    "Unexpected value for `string_value`"
 4433         -
                                );
 4434         -
                                ::pretty_assertions::assert_eq!(
 4435         -
                                    input.blob_value,
 4436         -
                                    expected.blob_value,
 4437         -
                                    "Unexpected value for `blob_value`"
 4438         -
                                );
 4439         -
                                let output = crate::output::SimpleScalarPropertiesOutput {
 4440         -
                                    true_boolean_value: ::std::option::Option::None,
 4441         -
                                    false_boolean_value: ::std::option::Option::None,
 4442         -
                                    byte_value: ::std::option::Option::None,
 4443         -
                                    double_value: ::std::option::Option::None,
 4444         -
                                    float_value: ::std::option::Option::None,
 4445         -
                                    integer_value: ::std::option::Option::None,
 4446         -
                                    long_value: ::std::option::Option::None,
 4447         -
                                    short_value: ::std::option::Option::None,
 4448         -
                                    string_value: ::std::option::Option::None,
 4449         -
                                    blob_value: ::std::option::Option::None,
 4450         -
                                };
 4451         -
                                output
 4452         -
                            };
 4453         -
                            sender.send(()).await.expect("receiver dropped early");
 4454         -
                            result
 4455         -
                        }
 4456         -
                    },
 4457         -
                )
 4458         -
                .build_unchecked();
 4459         -
        let http_response = ::tower::ServiceExt::oneshot(service, http_request)
 4460         -
            .await
 4461         -
            .expect("unable to make an HTTP request");
 4462         -
        assert!(
 4463         -
            receiver.recv().await.is_some(),
 4464         -
            "we expected operation handler to be invoked but it was not entered"
 4465         -
        );
 4466         -
    }
 4467         -
 4468   4319   
    /// Serializes simple scalar properties
 4469   4320   
    /// Test ID: RpcV2CborSimpleScalarProperties
 4470   4321   
    #[::tokio::test]
 4471   4322   
    #[::tracing_test::traced_test]
 4472   4323   
    async fn rpc_v2_cbor_simple_scalar_properties_response() {
 4473   4324   
        let output = crate::output::SimpleScalarPropertiesOutput {
 4474   4325   
            true_boolean_value: ::std::option::Option::Some(true),
 4475   4326   
            false_boolean_value: ::std::option::Option::Some(false),
 4476   4327   
            byte_value: ::std::option::Option::Some(5),
 4477   4328   
            double_value: ::std::option::Option::Some(1.889_f64),
@@ -4760,4611 +4820,4670 @@
 4780   4631   
 4781   4632   
    /// When input is empty we write CBOR equivalent of {}
 4782   4633   
    /// Test ID: optional_input
 4783   4634   
    #[::tokio::test]
 4784   4635   
    #[::tracing_test::traced_test]
 4785   4636   
    async fn optional_input_request() {
 4786   4637   
        #[allow(unused_mut)]
 4787   4638   
        let mut http_request = http::Request::builder()
 4788   4639   
            .uri("/service/RpcV2Protocol/operation/OptionalInputOutput")
 4789   4640   
            .method("POST")
 4790         -
            .header("Accept", "application/cbor")
 4791   4641   
            .header("Content-Type", "application/cbor")
 4792   4642   
            .header("smithy-protocol", "rpc-v2-cbor")
 4793   4643   
            .body(::aws_smithy_http_server::body::Body::from(
 4794   4644   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 4795   4645   
                    "v/8=".as_bytes(),
 4796   4646   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 4797   4647   
                )),
 4798   4648   
            ))
 4799   4649   
            .unwrap();
 4800   4650   
        #[allow(unused_mut)]
@@ -4939,4789 +5046,4894 @@
 4959   4809   
 4960   4810   
    /// When Input structure is empty we write CBOR equivalent of {}
 4961   4811   
    /// Test ID: empty_input
 4962   4812   
    #[::tokio::test]
 4963   4813   
    #[::tracing_test::traced_test]
 4964   4814   
    async fn empty_input_request() {
 4965   4815   
        #[allow(unused_mut)]
 4966   4816   
        let mut http_request = http::Request::builder()
 4967   4817   
            .uri("/service/RpcV2Protocol/operation/EmptyInputOutput")
 4968   4818   
            .method("POST")
 4969         -
            .header("Accept", "application/cbor")
 4970   4819   
            .header("Content-Type", "application/cbor")
 4971   4820   
            .header("smithy-protocol", "rpc-v2-cbor")
 4972   4821   
            .body(::aws_smithy_http_server::body::Body::from(
 4973   4822   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 4974   4823   
                    "v/8=".as_bytes(),
 4975   4824   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 4976   4825   
                )),
 4977   4826   
            ))
 4978   4827   
            .unwrap();
 4979   4828   
        #[allow(unused_mut)]
 4980   4829   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
 4981   4830   
        let config = crate::service::RpcV2ProtocolConfig::builder().build();
 4982   4831   
        let service =
 4983   4832   
            crate::service::RpcV2Protocol::builder::<::hyper::body::Body, _, _, _>(config)
 4984   4833   
                .empty_input_output(move |input: crate::input::EmptyInputOutputInput| {
 4985   4834   
                    let sender = sender.clone();
 4986   4835   
                    async move {
 4987   4836   
                        let result = {
 4988   4837   
                            let expected = crate::input::EmptyInputOutputInput {};
 4989   4838   
                            ::pretty_assertions::assert_eq!(input, expected);
 4990   4839   
                            let output = crate::output::EmptyInputOutputOutput {};
 4991   4840   
                            output
 4992   4841   
                        };
 4993   4842   
                        sender.send(()).await.expect("receiver dropped early");
 4994   4843   
                        result
 4995   4844   
                    }
 4996   4845   
                })
 4997   4846   
                .build_unchecked();
 4998   4847   
        let http_response = ::tower::ServiceExt::oneshot(service, http_request)
 4999   4848   
            .await
 5000   4849   
            .expect("unable to make an HTTP request");
 5001   4850   
        assert!(
 5002   4851   
            receiver.recv().await.is_some(),
 5003   4852   
            "we expected operation handler to be invoked but it was not entered"
 5004   4853   
        );
 5005   4854   
    }
 5006   4855   
 5007   4856   
    /// When Input structure is empty the server should accept an empty body
 5008   4857   
    /// Test ID: empty_input_no_body
 5009   4858   
    #[::tokio::test]
 5010   4859   
    #[::tracing_test::traced_test]
 5011   4860   
    async fn empty_input_no_body_request() {
 5012   4861   
        #[allow(unused_mut)]
 5013   4862   
        let mut http_request = http::Request::builder()
 5014   4863   
            .uri("/service/RpcV2Protocol/operation/EmptyInputOutput")
 5015   4864   
            .method("POST")
 5016         -
            .header("Accept", "application/cbor")
 5017   4865   
            .header("Content-Type", "application/cbor")
 5018   4866   
            .header("smithy-protocol", "rpc-v2-cbor")
 5019   4867   
            .body(::aws_smithy_http_server::body::Body::from(
 5020   4868   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 5021   4869   
                    "".as_bytes(),
 5022   4870   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
 5023   4871   
                )),
 5024   4872   
            ))
 5025   4873   
            .unwrap();
 5026   4874   
        #[allow(unused_mut)]
@@ -5192,5040 +5252,5099 @@
 5212   5060   
 5213   5061   
    /// Body is empty and no Content-Type header if no input
 5214   5062   
    /// Test ID: no_input
 5215   5063   
    #[::tokio::test]
 5216   5064   
    #[::tracing_test::traced_test]
 5217   5065   
    async fn no_input_request() {
 5218   5066   
        #[allow(unused_mut)]
 5219   5067   
        let mut http_request = http::Request::builder()
 5220   5068   
            .uri("/service/RpcV2Protocol/operation/NoInputOutput")
 5221   5069   
            .method("POST")
 5222         -
            .header("Accept", "application/cbor")
 5223   5070   
            .header("smithy-protocol", "rpc-v2-cbor")
 5224   5071   
            .body(::aws_smithy_http_server::body::Body::from(
 5225   5072   
                ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
 5226   5073   
                    "".as_bytes(),
 5227   5074   
                    ::aws_smithy_protocol_test::MediaType::from("unknown"),
 5228   5075   
                )),
 5229   5076   
            ))
 5230   5077   
            .unwrap();
 5231   5078   
        #[allow(unused_mut)]
 5232   5079   
        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);