Server Test

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(missing_docs)] // documentation missing in model

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub struct ContentTypeParametersInput {

    #[allow(missing_docs)] // documentation missing in model

    pub value: ::std::option::Option<i32>,

}

impl ContentTypeParametersInput {

    #[allow(missing_docs)] // documentation missing in model

    pub fn value(&self) -> ::std::option::Option<i32> {

        self.value

    }

}

impl ContentTypeParametersInput {

    /// Creates a new builder-style object to manufacture [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).

    pub fn builder() -> crate::input::content_type_parameters_input::Builder {

        crate::input::content_type_parameters_input::Builder::default()

    }

}

impl crate::constrained::Constrained for crate::input::ContentTypeParametersInput {

    type Unconstrained = crate::input::content_type_parameters_input::Builder;

}

/// See [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).

///

pub mod content_type_parameters_input {

    impl ::std::convert::From<Builder> for crate::input::ContentTypeParametersInput {

        fn from(builder: Builder) -> Self {

            builder.build()

        }

    }

    /// A builder for [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) value: ::std::option::Option<i32>,

    }

    impl Builder {

        #[allow(missing_docs)] // documentation missing in model

        pub fn value(mut self, input: ::std::option::Option<i32>) -> Self {

            self.value = input;

            self

        }

        #[allow(missing_docs)] // documentation missing in model

        pub(crate) fn set_value(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {

            self.value = input.map(|v| v.into());

            self

        }

        /// Consumes the builder and constructs a [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).

        pub fn build(self) -> crate::input::ContentTypeParametersInput {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(self) -> crate::input::ContentTypeParametersInput {

            crate::input::ContentTypeParametersInput { value: self.value }

        }

    }

}

#![allow(deprecated)]

#![allow(unknown_lints)]

#![allow(clippy::module_inception)]

#![allow(clippy::upper_case_acronyms)]

#![allow(clippy::large_enum_variant)]

#![allow(clippy::wrong_self_convention)]

#![allow(clippy::should_implement_trait)]

#![allow(clippy::disallowed_names)]

#![allow(clippy::vec_init_then_push)]

#![allow(clippy::type_complexity)]

#![allow(clippy::needless_return)]

#![allow(clippy::derive_partial_eq_without_eq)]

#![allow(clippy::result_large_err)]

#![allow(clippy::unnecessary_map_on_constructor)]

#![allow(rustdoc::bare_urls)]

#![allow(rustdoc::redundant_explicit_links)]

#![forbid(unsafe_code)]

#![cfg_attr(docsrs, feature(doc_auto_cfg))]

//! A REST XML service that sends XML requests and responses.

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

//! A fast and customizable Rust implementation of the RestXmlExtras Smithy service.

//!

//! # Using RestXmlExtras

//!

//! The primary entrypoint is [`RestXmlExtras`]: it satisfies the [`Service<http::Request, Response = http::Response>`](::tower::Service)

//! trait and therefore can be handed to a [`hyper` server](https://github.com/hyperium/hyper) via [`RestXmlExtras::into_make_service`] or used in Lambda via [`LambdaHandler`](::aws_smithy_http_server::routing::LambdaHandler).

//! The [`crate::input`], and [`crate::output`],

//! modules provide the types used in each operation.

//!

//! ### Running on Hyper

//!

//! ```rust,no_run

//! # use std::net::SocketAddr;

//! # async fn dummy() {

//! use rest_xml_extras::{RestXmlExtras, RestXmlExtrasConfig};

//!

//! # let app = RestXmlExtras::builder(

//! #     RestXmlExtrasConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let server = app.into_make_service();

//! let bind: SocketAddr = "127.0.0.1:6969".parse()

//!     .expect("unable to parse the server bind address and port");

//! ::hyper::Server::bind(&bind).serve(server).await.unwrap();

//! # }

//! ```

//!

//! ### Running on Lambda

//!

//! This requires the `aws-lambda` feature flag to be passed to the [`::aws_smithy_http_server`] crate.

//!

//! ```rust,ignore

//! use ::aws_smithy_http_server::routing::LambdaHandler;

//! use rest_xml_extras::RestXmlExtras;

//!

//! # async fn dummy() {

//! # let app = RestXmlExtras::builder(

//! #     RestXmlExtrasConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let handler = LambdaHandler::new(app);

//! lambda_http::run(handler).await.unwrap();

//! # }

//! ```

//!

//! # Building the RestXmlExtras

//!

//! To construct [`RestXmlExtras`] we use [`RestXmlExtrasBuilder`] returned by [`RestXmlExtras::builder`].

//!

//! ## Plugins

//!

//! The [`RestXmlExtras::builder`] method, returning [`RestXmlExtrasBuilder`],

//! accepts a config object on which plugins can be registered.

//! Plugins allow you to build middleware which is aware of the operation it is being applied to.

//!

//! ```rust,no_run

//! # use ::aws_smithy_http_server::plugin::IdentityPlugin as LoggingPlugin;

//! # use ::aws_smithy_http_server::plugin::IdentityPlugin as MetricsPlugin;

//! # use ::hyper::Body;

//! use ::aws_smithy_http_server::plugin::HttpPlugins;

//! use rest_xml_extras::{RestXmlExtras, RestXmlExtrasConfig, RestXmlExtrasBuilder};

//!

//! let http_plugins = HttpPlugins::new()

//!         .push(LoggingPlugin)

//!         .push(MetricsPlugin);

//! let config = RestXmlExtrasConfig::builder().build();

//! let builder: RestXmlExtrasBuilder<Body, _, _, _> = RestXmlExtras::builder(config);

//! ```

//!

//! Check out [`::aws_smithy_http_server::plugin`] to learn more about plugins.

//!

//! ## Handlers

//!

//! [`RestXmlExtrasBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.

//! We call these async functions **handlers**. This is where your application business logic lives.

//!

//! Every handler must take an `Input`, and optional [`extractor arguments`](::aws_smithy_http_server::request), while returning:

//!

//! * A `Result<Output, Error>` if your operation has modeled errors, or

//! * An `Output` otherwise.

//!

//! ```rust,no_run

//! # struct Input;

//! # struct Output;

//! # struct Error;

//! async fn infallible_handler(input: Input) -> Output { todo!() }

//!

//! async fn fallible_handler(input: Input) -> Result<Output, Error> { todo!() }

//! ```

//!

//! Handlers can accept up to 8 extractors:

//!

//! ```rust,no_run

//! # struct Input;

//! # struct Output;

//! # struct Error;

//! # struct State;

//! # use std::net::SocketAddr;

//! use ::aws_smithy_http_server::request::{extension::Extension, connect_info::ConnectInfo};

//!

//! async fn handler_with_no_extensions(input: Input) -> Output {

//!     todo!()

//! }

//!

//! async fn handler_with_one_extractor(input: Input, ext: Extension<State>) -> Output {

//!     todo!()

//! }

//!

//! async fn handler_with_two_extractors(

//!     input: Input,

//!     ext0: Extension<State>,

//!     ext1: ConnectInfo<SocketAddr>,

//! ) -> Output {

//!     todo!()

//! }

//! ```

//!

//! See the [`operation module`](::aws_smithy_http_server::operation) for information on precisely what constitutes a handler.

//!

//! ## Build

//!

//! You can convert [`RestXmlExtrasBuilder`] into [`RestXmlExtras`] using either [`RestXmlExtrasBuilder::build`] or [`RestXmlExtrasBuilder::build_unchecked`].

//!

//! [`RestXmlExtrasBuilder::build`] requires you to provide a handler for every single operation in your Smithy model. It will return an error if that is not the case.

//!

//! [`RestXmlExtrasBuilder::build_unchecked`], instead, does not require exhaustiveness. The server will automatically return 500 Internal Server Error to all requests for operations that do not have a registered handler.

//! [`RestXmlExtrasBuilder::build_unchecked`] is particularly useful if you are deploying your Smithy service as a collection of Lambda functions, where each Lambda is only responsible for a subset of the operations in the Smithy service (or even a single one!).

//!

//! # Example

//!

//! ```rust,no_run

//! # use std::net::SocketAddr;

//! use rest_xml_extras::{RestXmlExtras, RestXmlExtrasConfig};

//!

//! #[::tokio::main]

//! pub async fn main() {

//!    let config = RestXmlExtrasConfig::builder().build();

//!    let app = RestXmlExtras::builder(config)

//!        .content_type_parameters(content_type_parameters)

//!        .build()

//!        .expect("failed to build an instance of RestXmlExtras");

//!

//!    let bind: SocketAddr = "127.0.0.1:6969".parse()

//!        .expect("unable to parse the server bind address and port");

//!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());

//!    # let server = async { Ok::<_, ()>(()) };

//!

//!    // Run your service!

//!    if let Err(err) = server.await {

//!        eprintln!("server error: {:?}", err);

//!    }

//! }

//!

//! use rest_xml_extras::{input, output};

//!

//! async fn content_type_parameters(input: input::ContentTypeParametersInput) -> output::ContentTypeParametersOutput {

//!     todo!()

//! }

//!

//! ```

//!

//! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve

//! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html

//! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html

//! [operations]: https://smithy.io/2.0/spec/service-types.html#operation

//! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html

//! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html

pub use crate::service::{

    MissingOperationsError, RestXmlExtras, RestXmlExtrasBuilder, RestXmlExtrasConfig,

    RestXmlExtrasConfigBuilder,

};

/// Crate version number.

pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

/// All error types that operations can return. Documentation on these types is copied from the model.

pub mod error;

/// Input structures for operations. Documentation on these types is copied from the model.

pub mod input;

/// All operations that this crate can perform.

pub mod operation;

/// A collection of types representing each operation defined in the service closure.

///

/// The [plugin system](::aws_smithy_http_server::plugin) makes use of these

/// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to

/// parameterize [`Plugin`](::aws_smithy_http_server::plugin::Plugin) implementations. Their traits, such as

/// [`OperationShape`](::aws_smithy_http_server::operation::OperationShape), can be used to provide

/// operation specific information to the [`Layer`](::tower::Layer) being applied.

pub mod operation_shape;

/// Output structures for operations. Documentation on these types is copied from the model.

pub mod output;

/// Contains the types that are re-exported from the `aws-smithy-http-server` crate.

pub mod server;

mod service;

/// Data primitives referenced by other data types.

pub mod types;

/// Constrained types for constrained shapes.

mod constrained;

pub(crate) mod protocol_serde;

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput) using modelled bindings.

    pub struct ContentTypeParametersInputFuture {

        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ContentTypeParametersInput, ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError>> + Send>>

    }

}

impl std::future::Future for ContentTypeParametersInputFuture {

    type Output = Result<

        crate::input::ContentTypeParametersInput,

        ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_xml::RestXml,

        B,

    > for crate::input::ContentTypeParametersInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError;

    type Future = ContentTypeParametersInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

            crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)

                            .await

                            .map_err(Into::into)

        };

        use ::futures_util::future::TryFutureExt;

        let fut = fut.map_err(

            |e: ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection| {

                ::tracing::debug!(error = %e, "failed to deserialize request");

                ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e)

            },

        );

        ContentTypeParametersInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_xml::RestXml,

    > for crate::output::ContentTypeParametersOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_xml::RestXml>::into_response(::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod content_type_parameters_test {

    /// A server should ignore parameters added to the content type

    /// Test ID: RestXmlMustSupportParametersInContentType

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_xml_must_support_parameters_in_content_type_request() {

        #[allow(unused_mut)]

        let mut http_request = http::Request::builder()

            .uri("/ContentTypeParameters")

            .method("PUT")

            .header("Content-Type", "application/xml; charset=utf-8")

            .body(::aws_smithy_http_server::body::Body::from(

                ::bytes::Bytes::from_static(

                    "<ContentTypeParametersInput><value>5</value></ContentTypeParametersInput>"

                        .as_bytes(),

                ),

            ))

            .unwrap();

        #[allow(unused_mut)]

        let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);

        let config = crate::service::RestXmlExtrasConfig::builder().build();

        let service =

            crate::service::RestXmlExtras::builder::<::hyper::body::Body, _, _, _>(config)

                .content_type_parameters(move |input: crate::input::ContentTypeParametersInput| {

                    let sender = sender.clone();

                    async move {

                        let result = {

                            let expected = crate::input::ContentTypeParametersInput {

                                value: ::std::option::Option::Some(5),

                            };

                            ::pretty_assertions::assert_eq!(input, expected);

                            let response = crate::output::ContentTypeParametersOutput {};

                            response

                        };

                        sender.send(()).await.expect("receiver dropped early");

                        result

                    }

                })

                .build_unchecked();

        let http_response = ::tower::ServiceExt::oneshot(service, http_request)

            .await

            .expect("unable to make an HTTP request");

        assert!(

            receiver.recv().await.is_some(),

            "we expected operation handler to be invoked but it was not entered"

        );

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// The example tests how servers must support requests containing a `Content-Type` header with parameters.

pub struct ContentTypeParameters;

impl ::aws_smithy_http_server::operation::OperationShape for ContentTypeParameters {

    const ID: ::aws_smithy_http_server::shape_id::ShapeId =

        ::aws_smithy_http_server::shape_id::ShapeId::new(

            "aws.protocoltests.restxml#ContentTypeParameters",

            "aws.protocoltests.restxml",

            "ContentTypeParameters",

        );

    type Input = crate::input::ContentTypeParametersInput;

    type Output = crate::output::ContentTypeParametersOutput;

    type Error = std::convert::Infallible;

}

impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for ContentTypeParameters {

    type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<

        ::aws_smithy_http_server::instrumentation::MakeIdentity,

        ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<

            ::aws_smithy_http_server::instrumentation::MakeIdentity,

            ::aws_smithy_http_server::instrumentation::MakeIdentity,

        >,

    >;

    type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<

        ::aws_smithy_http_server::instrumentation::MakeIdentity,

        ::aws_smithy_http_server::instrumentation::MakeIdentity,

    >;

    fn request_fmt() -> Self::RequestFmt {

        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()

    }

    fn response_fmt() -> Self::ResponseFmt {

        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(missing_docs)] // documentation missing in model

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub struct ContentTypeParametersOutput {}

impl ContentTypeParametersOutput {

    /// Creates a new builder-style object to manufacture [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).

    pub fn builder() -> crate::output::content_type_parameters_output::Builder {

        crate::output::content_type_parameters_output::Builder::default()

    }

}

/// See [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).

///

pub mod content_type_parameters_output {

    impl ::std::convert::From<Builder> for crate::output::ContentTypeParametersOutput {

        fn from(builder: Builder) -> Self {

            builder.build()

        }

    }

    /// A builder for [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {}

    impl Builder {

        /// Consumes the builder and constructs a [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).

        pub fn build(self) -> crate::output::ContentTypeParametersOutput {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(self) -> crate::output::ContentTypeParametersOutput {

            crate::output::ContentTypeParametersOutput {}

        }

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub(crate) mod shape_content_type_parameters;

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub mod body {

    pub use ::aws_smithy_http_server::body::BoxBody;

}

pub mod operation {

    pub use ::aws_smithy_http_server::operation::OperationShape;

}

pub mod plugin {

    pub use ::aws_smithy_http_server::plugin::HttpMarker;

    pub use ::aws_smithy_http_server::plugin::HttpPlugins;

    pub use ::aws_smithy_http_server::plugin::ModelMarker;

    pub use ::aws_smithy_http_server::plugin::ModelPlugins;

    pub use ::aws_smithy_http_server::plugin::Plugin;

    pub use ::aws_smithy_http_server::plugin::PluginStack;

}

pub mod request {

    pub use ::aws_smithy_http_server::request::FromParts;

    #[cfg(feature = "aws-lambda")]

    pub mod lambda {

        pub use ::aws_smithy_http_server::request::lambda::Context;

    }

}

pub mod response {

    pub use ::aws_smithy_http_server::response::IntoResponse;

}

pub mod routing {

    pub use ::aws_smithy_http_server::routing::IntoMakeService;

    pub use ::aws_smithy_http_server::routing::IntoMakeServiceWithConnectInfo;

    pub use ::aws_smithy_http_server::routing::Router;

    #[cfg(feature = "aws-lambda")]

    pub use ::aws_smithy_http_server::routing::LambdaHandler;

}

pub use ::aws_smithy_http_server::instrumentation;

pub use ::aws_smithy_http_server::protocol;

pub use ::aws_smithy_http_server::Extension;

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// The service builder for [`RestXmlExtras`].

///

/// Constructed via [`RestXmlExtras::builder`].

pub struct RestXmlExtrasBuilder<Body, L, HttpPl, ModelPl> {

    content_type_parameters: Option<::aws_smithy_http_server::routing::Route<Body>>,

    layer: L,

    http_plugin: HttpPl,

    model_plugin: ModelPl,

}

impl<Body, L, HttpPl, ModelPl> RestXmlExtrasBuilder<Body, L, HttpPl, ModelPl> {

    /// Sets the [`ContentTypeParameters`](crate::operation_shape::ContentTypeParameters) operation.

    ///

    /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.

    /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.

    ///

    /// # Example

    ///

    /// ```no_run

    /// use rest_xml_extras::{RestXmlExtras, RestXmlExtrasConfig};

    ///

    /// use rest_xml_extras::{input, output};

    ///

    /// async fn handler(input: input::ContentTypeParametersInput) -> output::ContentTypeParametersOutput {

    ///     todo!()

    /// }

    ///

    /// let config = RestXmlExtrasConfig::builder().build();

    /// let app = RestXmlExtras::builder(config)

    ///     .content_type_parameters(handler)

    ///     /* Set other handlers */

    ///     .build()

    ///     .unwrap();

    /// # let app: RestXmlExtras<::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_xml::RestXml>> = app;

    /// ```

    ///

                    pub fn content_type_parameters<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self

                    where

                        HandlerType: ::aws_smithy_http_server::operation::Handler<crate::operation_shape::ContentTypeParameters, HandlerExtractors>,

                        ModelPl: ::aws_smithy_http_server::plugin::Plugin<

                            RestXmlExtras<L>,

                            crate::operation_shape::ContentTypeParameters,

                            ::aws_smithy_http_server::operation::IntoService<crate::operation_shape::ContentTypeParameters, HandlerType>

                        >,

                        ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<

                            RestXmlExtras<L>,

                            crate::operation_shape::ContentTypeParameters,

                            ModelPl::Output

                        >,

                        HttpPl: ::aws_smithy_http_server::plugin::Plugin<

                            RestXmlExtras<L>,

                            crate::operation_shape::ContentTypeParameters,

                            <

                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>

                                as ::aws_smithy_http_server::plugin::Plugin<

                                    RestXmlExtras<L>,

                                    crate::operation_shape::ContentTypeParameters,

                                    ModelPl::Output

                                >

                            >::Output

                        >,

                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,

                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,

                    {

        use ::aws_smithy_http_server::operation::OperationShapeExt;

        use ::aws_smithy_http_server::plugin::Plugin;

        let svc = crate::operation_shape::ContentTypeParameters::from_handler(handler);

        let svc = self.model_plugin.apply(svc);

        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()

            .apply(svc);

        let svc = self.http_plugin.apply(svc);

        self.content_type_parameters_custom(svc)

    }

    /// Sets the [`ContentTypeParameters`](crate::operation_shape::ContentTypeParameters) operation.

    ///

    /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.

    /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.

    ///

    /// # Example

    ///

    /// ```no_run

    /// use rest_xml_extras::{RestXmlExtras, RestXmlExtrasConfig};

    ///

    /// use rest_xml_extras::{input, output};

    ///

    /// async fn handler(input: input::ContentTypeParametersInput) -> Result<output::ContentTypeParametersOutput, std::convert::Infallible> {

    ///     todo!()

    /// }

    ///

    /// let config = RestXmlExtrasConfig::builder().build();

    /// let svc = ::tower::util::service_fn(handler);

    /// let app = RestXmlExtras::builder(config)

    ///     .content_type_parameters_service(svc)

    ///     /* Set other handlers */

    ///     .build()

    ///     .unwrap();

    /// # let app: RestXmlExtras<::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_xml::RestXml>> = app;

    /// ```

    ///

                    pub fn content_type_parameters_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self

                    where

                        S: ::aws_smithy_http_server::operation::OperationService<crate::operation_shape::ContentTypeParameters, ServiceExtractors>,

                        ModelPl: ::aws_smithy_http_server::plugin::Plugin<

                            RestXmlExtras<L>,

                            crate::operation_shape::ContentTypeParameters,

                            ::aws_smithy_http_server::operation::Normalize<crate::operation_shape::ContentTypeParameters, S>

                        >,

                        ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>: ::aws_smithy_http_server::plugin::Plugin<

                            RestXmlExtras<L>,

                            crate::operation_shape::ContentTypeParameters,

                            ModelPl::Output

                        >,

                        HttpPl: ::aws_smithy_http_server::plugin::Plugin<

                            RestXmlExtras<L>,

                            crate::operation_shape::ContentTypeParameters,

                            <

                                ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>

                                as ::aws_smithy_http_server::plugin::Plugin<

                                    RestXmlExtras<L>,

                                    crate::operation_shape::ContentTypeParameters,

                                    ModelPl::Output

                                >

                            >::Output

                        >,

                        HttpPl::Output: ::tower::Service<::http::Request<Body>, Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>, Error = ::std::convert::Infallible> + Clone + Send + 'static,

                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,

                    {

        use ::aws_smithy_http_server::operation::OperationShapeExt;

        use ::aws_smithy_http_server::plugin::Plugin;

        let svc = crate::operation_shape::ContentTypeParameters::from_service(service);

        let svc = self.model_plugin.apply(svc);

        let svc = ::aws_smithy_http_server::operation::UpgradePlugin::<UpgradeExtractors>::new()

            .apply(svc);

        let svc = self.http_plugin.apply(svc);

        self.content_type_parameters_custom(svc)

    }

    /// Sets the [`ContentTypeParameters`](crate::operation_shape::ContentTypeParameters) to a custom [`Service`](tower::Service).

    /// not constrained by the Smithy contract.

    fn content_type_parameters_custom<S>(mut self, svc: S) -> Self

    where

        S: ::tower::Service<

                ::http::Request<Body>,

                Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,

                Error = ::std::convert::Infallible,

            > + Clone

            + Send

            + 'static,

        S::Future: Send + 'static,

    {

        self.content_type_parameters = Some(::aws_smithy_http_server::routing::Route::new(svc));

        self

    }

}

impl<Body, L, HttpPl, ModelPl> RestXmlExtrasBuilder<Body, L, HttpPl, ModelPl> {

    /// Constructs a [`RestXmlExtras`] from the arguments provided to the builder.

    ///

    /// Forgetting to register a handler for one or more operations will result in an error.

    ///

    /// Check out [`RestXmlExtrasBuilder::build_unchecked`] if you'd prefer the service to return status code 500 when an

    /// unspecified route is requested.

    pub fn build(

        self,

    ) -> Result<

        RestXmlExtras<

            ::aws_smithy_http_server::routing::RoutingService<

                ::aws_smithy_http_server::protocol::rest::router::RestRouter<L::Service>,

                ::aws_smithy_http_server::protocol::rest_xml::RestXml,

            >,

        >,

        MissingOperationsError,

    >

    where

        L: ::tower::Layer<::aws_smithy_http_server::routing::Route<Body>>,

    {

        let router = {

            use ::aws_smithy_http_server::operation::OperationShape;

            let mut missing_operation_names = std::collections::HashMap::new();

            if self.content_type_parameters.is_none() {

                missing_operation_names.insert(

                    crate::operation_shape::ContentTypeParameters::ID,

                    ".content_type_parameters()",

                );

            }

            if !missing_operation_names.is_empty() {

                return Err(MissingOperationsError {

                    operation_names2setter_methods: missing_operation_names,

                });

            }

            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";

            ::aws_smithy_http_server::protocol::rest::router::RestRouter::from_iter([(

                request_specs::content_type_parameters(),

                self.content_type_parameters.expect(unexpected_error_msg),

            )])

        };

        let svc = ::aws_smithy_http_server::routing::RoutingService::new(router);

        let svc = svc.map(|s| s.layer(self.layer));

        Ok(RestXmlExtras { svc })

    }

    /// Constructs a [`RestXmlExtras`] from the arguments provided to the builder.

    /// Operations without a handler default to returning 500 Internal Server Error to the caller.

    ///

    /// Check out [`RestXmlExtrasBuilder::build`] if you'd prefer the builder to fail if one or more operations do

    /// not have a registered handler.

    pub fn build_unchecked(self) -> RestXmlExtras<L::Service>

    where

        Body: Send + 'static,

        L: ::tower::Layer<

            ::aws_smithy_http_server::routing::RoutingService<

                ::aws_smithy_http_server::protocol::rest::router::RestRouter<

                    ::aws_smithy_http_server::routing::Route<Body>,

                >,

                ::aws_smithy_http_server::protocol::rest_xml::RestXml,

            >,

        >,

    {

        let router = ::aws_smithy_http_server::protocol::rest::router::RestRouter::from_iter([(

            request_specs::content_type_parameters(),

            self.content_type_parameters.unwrap_or_else(|| {

                let svc = ::aws_smithy_http_server::operation::MissingFailure::<

                    ::aws_smithy_http_server::protocol::rest_xml::RestXml,

                >::default();

                ::aws_smithy_http_server::routing::Route::new(svc)

            }),

        )]);

        let svc = self

            .layer

            .layer(::aws_smithy_http_server::routing::RoutingService::new(

                router,

            ));

        RestXmlExtras { svc }

    }

}

/// The error encountered when calling the [`RestXmlExtrasBuilder::build`] method if one or more operation handlers are not

/// specified.

#[derive(Debug)]

pub struct MissingOperationsError {

    operation_names2setter_methods:

        std::collections::HashMap<::aws_smithy_http_server::shape_id::ShapeId, &'static str>,

}

impl std::fmt::Display for MissingOperationsError {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        write!(

            f,

            "You must specify a handler for all operations attached to `RestXmlExtras`.\n\

                            We are missing handlers for the following operations:\n",

        )?;

        for operation_name in self.operation_names2setter_methods.keys() {

            writeln!(f, "- {}", operation_name.absolute())?;

        }

        writeln!(f, "\nUse the dedicated methods on `RestXmlExtrasBuilder` to register the missing handlers:")?;

        for setter_name in self.operation_names2setter_methods.values() {

            writeln!(f, "- {}", setter_name)?;

        }

        Ok(())

    }

}

impl std::error::Error for MissingOperationsError {}

mod request_specs {

    pub(super) fn content_type_parameters(

    ) -> ::aws_smithy_http_server::routing::request_spec::RequestSpec {

        ::aws_smithy_http_server::routing::request_spec::RequestSpec::new(

                    ::http::Method::PUT,

                    ::aws_smithy_http_server::routing::request_spec::UriSpec::new(

                        ::aws_smithy_http_server::routing::request_spec::PathAndQuerySpec::new(

                            ::aws_smithy_http_server::routing::request_spec::PathSpec::from_vector_unchecked(vec![

    ::aws_smithy_http_server::routing::request_spec::PathSegment::Literal(String::from("ContentTypeParameters")),

]),

                            ::aws_smithy_http_server::routing::request_spec::QuerySpec::from_vector_unchecked(vec![

])

                        )

                    ),

                )

    }

}

/// A REST XML service that sends XML requests and responses.

///

/// See the [root](crate) documentation for more information.

#[derive(Clone)]

pub struct RestXmlExtras<

    S = ::aws_smithy_http_server::routing::RoutingService<

        ::aws_smithy_http_server::protocol::rest::router::RestRouter<

            ::aws_smithy_http_server::routing::Route<::aws_smithy_http_server::body::BoxBody>,

        >,

        ::aws_smithy_http_server::protocol::rest_xml::RestXml,

    >,

> {

    // This is the router wrapped by layers.

    svc: S,

}

impl RestXmlExtras<()> {

    /// Constructs a builder for [`RestXmlExtras`].

    /// You must specify a configuration object holding any plugins and layers that should be applied

    /// to the operations in this service.

    pub fn builder<

        Body,

        L,

        HttpPl: ::aws_smithy_http_server::plugin::HttpMarker,

        ModelPl: ::aws_smithy_http_server::plugin::ModelMarker,

    >(

        config: RestXmlExtrasConfig<L, HttpPl, ModelPl>,

    ) -> RestXmlExtrasBuilder<Body, L, HttpPl, ModelPl> {

        RestXmlExtrasBuilder {

            content_type_parameters: None,

            layer: config.layers,

            http_plugin: config.http_plugins,

            model_plugin: config.model_plugins,

        }

    }

    /// Constructs a builder for [`RestXmlExtras`].

    /// You must specify what plugins should be applied to the operations in this service.

    ///

    /// Use [`RestXmlExtras::builder_without_plugins`] if you don't need to apply plugins.

    ///

    /// Check out [`HttpPlugins`](::aws_smithy_http_server::plugin::HttpPlugins) and

    /// [`ModelPlugins`](::aws_smithy_http_server::plugin::ModelPlugins) if you need to apply

    /// multiple plugins.

    #[deprecated(

        since = "0.57.0",

        note = "please use the `builder` constructor and register plugins on the `RestXmlExtrasConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"

    )]

    pub fn builder_with_plugins<

        Body,

        HttpPl: ::aws_smithy_http_server::plugin::HttpMarker,

        ModelPl: ::aws_smithy_http_server::plugin::ModelMarker,

    >(

        http_plugin: HttpPl,

        model_plugin: ModelPl,

    ) -> RestXmlExtrasBuilder<Body, ::tower::layer::util::Identity, HttpPl, ModelPl> {

        RestXmlExtrasBuilder {

            content_type_parameters: None,

            layer: ::tower::layer::util::Identity::new(),

            http_plugin,

            model_plugin,

        }

    }

    /// Constructs a builder for [`RestXmlExtras`].

    ///

    /// Use [`RestXmlExtras::builder_with_plugins`] if you need to specify plugins.

    #[deprecated(

        since = "0.57.0",

        note = "please use the `builder` constructor instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"

    )]

    pub fn builder_without_plugins<Body>() -> RestXmlExtrasBuilder<

        Body,

        ::tower::layer::util::Identity,

        ::aws_smithy_http_server::plugin::IdentityPlugin,

        ::aws_smithy_http_server::plugin::IdentityPlugin,

    > {

        Self::builder_with_plugins(

            ::aws_smithy_http_server::plugin::IdentityPlugin,

            ::aws_smithy_http_server::plugin::IdentityPlugin,

        )

    }

}

impl<S> RestXmlExtras<S> {

    /// Converts [`RestXmlExtras`] into a [`MakeService`](tower::make::MakeService).

    pub fn into_make_service(self) -> ::aws_smithy_http_server::routing::IntoMakeService<Self> {

        ::aws_smithy_http_server::routing::IntoMakeService::new(self)

    }

    /// Converts [`RestXmlExtras`] into a [`MakeService`](tower::make::MakeService) with [`ConnectInfo`](::aws_smithy_http_server::request::connect_info::ConnectInfo).

    pub fn into_make_service_with_connect_info<C>(

        self,

    ) -> ::aws_smithy_http_server::routing::IntoMakeServiceWithConnectInfo<Self, C> {

        ::aws_smithy_http_server::routing::IntoMakeServiceWithConnectInfo::new(self)

    }

}

impl<S>

    RestXmlExtras<

        ::aws_smithy_http_server::routing::RoutingService<

            ::aws_smithy_http_server::protocol::rest::router::RestRouter<S>,

            ::aws_smithy_http_server::protocol::rest_xml::RestXml,

        >,

    >

{

    /// Applies a [`Layer`](::tower::Layer) uniformly to all routes.

    #[deprecated(

        since = "0.57.0",

        note = "please add layers to the `RestXmlExtrasConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"

    )]

    pub fn layer<L>(

        self,

        layer: &L,

    ) -> RestXmlExtras<

        ::aws_smithy_http_server::routing::RoutingService<

            ::aws_smithy_http_server::protocol::rest::router::RestRouter<L::Service>,

            ::aws_smithy_http_server::protocol::rest_xml::RestXml,

        >,

    >

    where

        L: ::tower::Layer<S>,

    {

        RestXmlExtras {

            svc: self.svc.map(|s| s.layer(layer)),

        }

    }

    /// Applies [`Route::new`](::aws_smithy_http_server::routing::Route::new) to all routes.

    ///

    /// This has the effect of erasing all types accumulated via layers.

    pub fn boxed<B>(

        self,

    ) -> RestXmlExtras<

        ::aws_smithy_http_server::routing::RoutingService<

            ::aws_smithy_http_server::protocol::rest::router::RestRouter<

                ::aws_smithy_http_server::routing::Route<B>,

            >,

            ::aws_smithy_http_server::protocol::rest_xml::RestXml,

        >,

    >

    where

        S: ::tower::Service<

            ::http::Request<B>,

            Response = ::http::Response<::aws_smithy_http_server::body::BoxBody>,

            Error = std::convert::Infallible,

        >,

        S: Clone + Send + 'static,

        S::Future: Send + 'static,

    {

        self.layer(&::tower::layer::layer_fn(

            ::aws_smithy_http_server::routing::Route::new,

        ))

    }

}

impl<S, R> ::tower::Service<R> for RestXmlExtras<S>

where

    S: ::tower::Service<R>,

{

    type Response = S::Response;

    type Error = S::Error;

    type Future = S::Future;

    fn poll_ready(

        &mut self,

        cx: &mut std::task::Context,

    ) -> std::task::Poll<Result<(), Self::Error>> {

        self.svc.poll_ready(cx)

    }

    fn call(&mut self, request: R) -> Self::Future {

        self.svc.call(request)

    }

}

/// An enumeration of all [operations](https://smithy.io/2.0/spec/service-types.html#operation) in RestXmlExtras.

#[allow(clippy::enum_variant_names)]

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

pub enum Operation {

    ContentTypeParameters,

}

impl Operation {

    /// Returns the [operations](https://smithy.io/2.0/spec/service-types.html#operation) [`ShapeId`](::aws_smithy_http_server::shape_id::ShapeId).

    pub fn shape_id(&self) -> ::aws_smithy_http_server::shape_id::ShapeId {

        match self {

            Operation::ContentTypeParameters => ::aws_smithy_http_server::shape_id::ShapeId::new(

                "aws.protocoltests.restxml#ContentTypeParameters",

                "aws.protocoltests.restxml",

                "ContentTypeParameters",

            ),

        }

    }

}

impl<L>

    ::aws_smithy_http_server::service::ContainsOperation<

        crate::operation_shape::ContentTypeParameters,

    > for RestXmlExtras<L>

{

    const VALUE: Operation = Operation::ContentTypeParameters;

}

impl<S> ::aws_smithy_http_server::service::ServiceShape for RestXmlExtras<S> {

    const ID: ::aws_smithy_http_server::shape_id::ShapeId =

        ::aws_smithy_http_server::shape_id::ShapeId::new(

            "aws.protocoltests.restxml#RestXmlExtras",

            "aws.protocoltests.restxml",

            "RestXmlExtras",

        );

    const VERSION: Option<&'static str> = Some("2024-04-15");

    type Protocol = ::aws_smithy_http_server::protocol::rest_xml::RestXml;

    type Operations = Operation;

}

/// Configuration for the [`RestXmlExtras`]. This is the central place where to register and

/// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.

///

/// ```rust,no_run

/// # use rest_xml_extras::RestXmlExtrasConfig;

/// # use ::aws_smithy_http_server::plugin::IdentityPlugin;

/// # use ::tower::layer::util::Identity;

/// # let authentication_plugin = IdentityPlugin;

/// # let authorization_plugin = IdentityPlugin;

/// # let server_request_id_provider_layer = Identity::new();

/// let config = RestXmlExtrasConfig::builder()

///     // Layers get executed first...

///     .layer(server_request_id_provider_layer)

///     // ...then HTTP plugins...

///     .http_plugin(authentication_plugin)

///     // ...and right after deserialization, model plugins.

///     .model_plugin(authorization_plugin)

///     .build();

/// ```

///

/// See the [`plugin`] system for details.

///

/// [`plugin`]: ::aws_smithy_http_server::plugin

#[derive(::std::fmt::Debug)]

pub struct RestXmlExtrasConfig<L, H, M> {

    layers: L,

    http_plugins: H,

    model_plugins: M,

}

impl RestXmlExtrasConfig<(), (), ()> {

    /// Returns a builder to construct the configuration.

    pub fn builder() -> RestXmlExtrasConfigBuilder<

        ::tower::layer::util::Identity,

        ::aws_smithy_http_server::plugin::IdentityPlugin,

        ::aws_smithy_http_server::plugin::IdentityPlugin,

    > {

        RestXmlExtrasConfigBuilder {

            layers: ::tower::layer::util::Identity::new(),

            http_plugins: ::aws_smithy_http_server::plugin::IdentityPlugin,

            model_plugins: ::aws_smithy_http_server::plugin::IdentityPlugin,

        }

    }

}

/// Builder returned by [`RestXmlExtrasConfig::builder()`].

#[derive(::std::fmt::Debug)]

pub struct RestXmlExtrasConfigBuilder<L, H, M> {

    pub(crate) layers: L,

    pub(crate) http_plugins: H,

    pub(crate) model_plugins: M,

}

impl<L, H, M> RestXmlExtrasConfigBuilder<L, H, M> {

    /// Add a [`::tower::Layer`] to the service.

    pub fn layer<NewLayer>(

        self,

        layer: NewLayer,

    ) -> RestXmlExtrasConfigBuilder<::tower::layer::util::Stack<NewLayer, L>, H, M> {

        RestXmlExtrasConfigBuilder {

            layers: ::tower::layer::util::Stack::new(layer, self.layers),

            http_plugins: self.http_plugins,

            model_plugins: self.model_plugins,

        }

    }

    /// Add a HTTP [plugin] to the service.

    ///

    /// [plugin]: ::aws_smithy_http_server::plugin

    // We eagerly require `NewPlugin: HttpMarker`, despite not really needing it, because compiler

    // errors get _substantially_ better if the user makes a mistake.

    pub fn http_plugin<NewPlugin: ::aws_smithy_http_server::plugin::HttpMarker>(

        self,

        http_plugin: NewPlugin,

    ) -> RestXmlExtrasConfigBuilder<L, ::aws_smithy_http_server::plugin::PluginStack<NewPlugin, H>, M>

    {

        RestXmlExtrasConfigBuilder {

            layers: self.layers,

            http_plugins: ::aws_smithy_http_server::plugin::PluginStack::new(

                http_plugin,

                self.http_plugins,

            ),

            model_plugins: self.model_plugins,

        }

    }

    /// Add a model [plugin] to the service.

    ///

    /// [plugin]: ::aws_smithy_http_server::plugin

    // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler

    // errors get _substantially_ better if the user makes a mistake.

    pub fn model_plugin<NewPlugin: ::aws_smithy_http_server::plugin::ModelMarker>(

        self,

        model_plugin: NewPlugin,

    ) -> RestXmlExtrasConfigBuilder<L, H, ::aws_smithy_http_server::plugin::PluginStack<NewPlugin, M>>

    {

        RestXmlExtrasConfigBuilder {

            layers: self.layers,

            http_plugins: self.http_plugins,

            model_plugins: ::aws_smithy_http_server::plugin::PluginStack::new(

                model_plugin,

                self.model_plugins,

            ),

        }

    }

    /// Build the configuration.

    pub fn build(self) -> super::RestXmlExtrasConfig<L, H, M> {

        super::RestXmlExtrasConfig {

            layers: self.layers,

            http_plugins: self.http_plugins,

            model_plugins: self.model_plugins,

        }

    }

}

/// A macro to help with scoping [plugins](::aws_smithy_http_server::plugin) to a subset of all operations.

///

/// In contrast to [`aws_smithy_http_server::scope`](::aws_smithy_http_server::scope), this macro has knowledge

/// of the service and any operations _not_ specified will be placed in the opposing group.

///

/// # Example

///

/// ```rust

/// scope! {

///     /// Includes [`ContentTypeParameters`], excluding all other operations.

///     struct ScopeA {

///         includes: [ContentTypeParameters]

///     }

/// }

///

/// scope! {

///     /// Excludes [`ContentTypeParameters`], excluding all other operations.

///     struct ScopeB {

///         excludes: [ContentTypeParameters]

///     }

/// }

///

/// # use ::aws_smithy_http_server::plugin::{Plugin, Scoped};

/// # use rest_xml_extras::scope;

/// # struct MockPlugin;

/// # impl<S, Op, T> Plugin<S, Op, T> for MockPlugin { type Output = u32; fn apply(&self, input: T) -> u32 { 3 } }

/// # let scoped_a = Scoped::new::<ScopeA>(MockPlugin);

/// # let scoped_b = Scoped::new::<ScopeB>(MockPlugin);

/// # let a = Plugin::<(), rest_xml_extras::operation_shape::ContentTypeParameters, u64>::apply(&scoped_a, 6);

/// # let b = Plugin::<(), rest_xml_extras::operation_shape::ContentTypeParameters, u64>::apply(&scoped_b, 6);

/// # assert_eq!(a, 3_u32);

/// # assert_eq!(b, 6_u64);

/// ```

#[macro_export]

macro_rules! scope {

                    // Completed, render impls

                    (@ $ name: ident, $ contains: ident () ($($ temp: ident)*) ($($ not_member: ident)*)) => {

                        $(

                            impl ::aws_smithy_http_server::plugin::scoped::Membership<$ temp> for $ name {

                                type Contains = ::aws_smithy_http_server::plugin::scoped::$ contains;

                            }

                        )*

                        $(

                            impl ::aws_smithy_http_server::plugin::scoped::Membership<$ not_member> for $ name {

                                type Contains = ::aws_smithy_http_server::plugin::scoped::$ contains;

                            }

                        )*

                    };

                    // All `not_member`s exhausted, move `temp` into `not_member`

                    (@ $ name: ident, $ contains: ident ($($ member: ident)*) ($($ temp: ident)*) ()) => {

                        scope! { @ $ name, $ contains ($($ member)*) () ($($ temp)*) }

                    };

                        // ContentTypeParameters match found, pop from both `member` and `not_member`

                        (@ $ name: ident, $ contains: ident (ContentTypeParameters $($ member: ident)*) ($($ temp: ident)*) (ContentTypeParameters $($ not_member: ident)*)) => {

                            scope! { @ $ name, $ contains ($($ member)*) ($($ temp)*) ($($ not_member)*) }

                        };

                        // ContentTypeParameters match not found, pop from `not_member` into `temp` stack

                        (@ $ name: ident, $ contains: ident (ContentTypeParameters $($ member: ident)*) ($($ temp: ident)*) ($ other: ident $($ not_member: ident)*)) => {

                            scope! { @ $ name, $ contains (ContentTypeParameters $($ member)*) ($ other $($ temp)*) ($($ not_member)*) }

                        };

                    (

                        $(#[$ attrs:meta])*

                        $ vis:vis struct $ name:ident {

                            includes: [$($ include:ident),*]

                        }

                    ) => {

                        use $ crate::operation_shape::*;

                        ::aws_smithy_http_server::scope! {

                            $(#[$ attrs])*

                            $ vis struct $ name {

                                includes: [$($ include),*],

                                excludes: []

                            }

                        }

                        scope! { @ $ name, False ($($ include)*) () (ContentTypeParameters) }

                    };

                    (

                        $(#[$ attrs:meta])*

                        $ vis:vis struct $ name:ident {

                            excludes: [$($ exclude:ident),*]

                        }

                    ) => {

                        use $ crate::operation_shape::*;

                        ::aws_smithy_http_server::scope! {

                            $(#[$ attrs])*

                            $ vis struct $ name {

                                includes: [],

                                excludes: [$($ exclude),*]

                            }

                        }

                        scope! { @ $ name, True ($($ exclude)*) () (ContentTypeParameters) }

                    };

                }