Client Test

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<StreamingTraitsRequireLengthInput>()

            .ok_or("failed to downcast to StreamingTraitsRequireLengthInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let expected_headers = [("X-Foo", "Foo")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/StreamingTraitsRequireLength", "path was incorrect");

    }

}

/// Error type for the `StreamingTraitsRequireLengthError` operation.

#[non_exhaustive]

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

pub enum StreamingTraitsRequireLengthError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

       `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<StreamingTraitsWithMediaTypeInput>()

            .ok_or("failed to downcast to StreamingTraitsWithMediaTypeInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "blobby blob blob",

            ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/StreamingTraitsWithMediaType", "path was incorrect");

    }

    /// Serializes a blob in the HTTP payload with a content-type

    /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob

    #[::tokio::test]

    #[::tracing_test::traced_test]

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestBodyStructureInput>()

            .ok_or("failed to downcast to TestBodyStructureInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/body", "path was incorrect");

    }

}

/// Error type for the `TestBodyStructureError` operation.

#[non_exhaustive]

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

pub enum TestBodyStructureError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestGetNoInputNoPayloadInput>()

            .ok_or("failed to downcast to TestGetNoInputNoPayloadInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/no_input_no_payload", "path was incorrect");

    }

}

/// Error type for the `TestGetNoInputNoPayloadError` operation.

#[non_exhaustive]

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

pub enum TestGetNoInputNoPayloadError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

       `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

     \

    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-TestGetNoInputNoPayloadError) for what information is available for the error.")]

    Unhandled(crate::error::sealed_unhandled::Unhandled),

}

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestGetNoPayloadInput>()

            .ok_or("failed to downcast to TestGetNoPayloadInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let expected_headers = [("X-Amz-Test-Id", "t-12345")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let forbidden_headers = &["Content-Length", "Content-Type"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/no_payload", "path was incorrect");

    }

}

/// Error type for the `TestGetNoPayloadError` operation.

#[non_exhaustive]

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

pub enum TestGetNoPayloadError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestPayloadBlobInput>()

            .ok_or("failed to downcast to TestPayloadBlobInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "image/jpg")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let required_headers = &["Content-Length"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "1234",

            ::aws_smithy_protocol_test::MediaType::from("image/jpg"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/blob_payload", "path was incorrect");

    }

}

/// Error type for the `TestPayloadBlobError` operation.

#[non_exhaustive]

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

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestPayloadStructureInput>()

            .ok_or("failed to downcast to TestPayloadStructureInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let http_request = request_receiver.expect_request();

        let expected_headers = [("Content-Type", "application/json"), ("X-Amz-Test-Id", "t-12345")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let required_headers = &["Content-Length"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::require_headers(http_request.headers(), required_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(

            body,

            "{}",

            ::aws_smithy_protocol_test::MediaType::from("application/json"),

        ));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/payload", "path was incorrect");

    }

}

/// Error type for the `TestPayloadStructureError` operation.

#[non_exhaustive]

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

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestPostNoInputNoPayloadInput>()

            .ok_or("failed to downcast to TestPostNoInputNoPayloadInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/no_input_no_payload", "path was incorrect");

    }

}

/// Error type for the `TestPostNoInputNoPayloadError` operation.

#[non_exhaustive]

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

pub enum TestPostNoInputNoPayloadError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

       `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

     \

    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-TestPostNoInputNoPayloadError) for what information is available for the error.")]

    Unhandled(crate::error::sealed_unhandled::Unhandled),

}

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TestPostNoPayloadInput>()

            .ok_or("failed to downcast to TestPostNoPayloadInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

        let expected_headers = [("X-Amz-Test-Id", "t-12345")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let forbidden_headers = &["Content-Type"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(http_request.headers(), forbidden_headers));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &::bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/no_payload", "path was incorrect");

    }

}

/// Error type for the `TestPostNoPayloadError` operation.

#[non_exhaustive]

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

pub enum TestPostNoPayloadError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<TimestampFormatHeadersInput>()

            .ok_or("failed to downcast to TimestampFormatHeadersInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

            )))

            .set_member_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_default_format(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_target_epoch_seconds(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_target_http_date(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .set_target_date_time(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1576540098, 0_f64,

            )))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

            .input()

            .downcast_ref::<UnitInputAndOutputInput>()

            .ok_or("failed to downcast to UnitInputAndOutputInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod unit_input_and_output_test {

        ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/UnitInputAndOutput", "path was incorrect");

    }

    /// When an operation defines Unit output, the service will respond

    /// with an empty payload, and may optionally include the content-type

    /// header.

    /// Test ID: RestJsonUnitInputAndOutputNoOutput

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn rest_json_unit_input_and_output_no_output_response() {

        let expected_output = crate::operation::unit_input_and_output::UnitInputAndOutputOutput::builder().build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .status(200)

                .body(::aws_smithy_types::body::SdkBody::from(""))

                .unwrap(),

        )

        .unwrap();

        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

    ///     fn resolve_auth_scheme<'a>(

    ///         &'a self,

    ///         _params: &'a rest_json_extras::config::auth::Params,

    ///         _cfg: &'a ConfigBag,

    ///         _runtime_components: &'a RuntimeComponents,

    ///     ) -> AuthSchemeOptionsFuture<'a> {

    ///         // --snip--

    /// #      todo!()

    ///     }

    /// }

    ///

    /// let config = rest_json_extras::Config::builder()

    ///     .auth_scheme_resolver(CustomAuthSchemeResolver)

    ///     // other configurations

    ///     .build();

    /// ```

    pub fn auth_scheme_resolver(mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> Self {

        self.set_auth_scheme_resolver(auth_scheme_resolver);

        self

    }

    /// # Examples

    ///

    /// ```no_run

    /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;

    /// let config = rest_json_extras::Config::builder()

    ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])

    ///     // ...

    ///     .build();

    /// let client = rest_json_extras::Client::from_conf(config);

    /// ```

    pub fn auth_scheme_preference(

        mut self,

        preference: impl ::std::convert::Into<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,

    ) -> Self {

        self.set_auth_scheme_preference(::std::option::Option::Some(preference.into()));

        self

    }

    /// Set the auth scheme preference for an auth scheme resolver

    }

    fn runtime_components(

        &self,

        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,

    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

        ::std::borrow::Cow::Borrowed(&self.components)

    }

}

pub use ::aws_smithy_runtime::client::identity::IdentityCache;

pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;

pub use ::aws_smithy_types::config_bag::ConfigBag;

pub use ::aws_smithy_async::rt::sleep::Sleep;

pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {

    let mut configured_plugins = ::std::vec::Vec::new();

    ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);

    #[cfg(feature = "behavior-version-latest")]

                                .with_config(config.config.clone())

                                .with_runtime_components(config.runtime_components.clone())

                        )

                        // codegen config

                        .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))

                        .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())

                        .with_client_plugin(

                            ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()

                                .with_scope(scope)

                                .with_time_source(config.runtime_components.time_source().unwrap_or_default())

                                .build()

                                .expect("All required fields have been set")

                        );

    for plugin in configured_plugins {

        plugins = plugins.with_client_plugin(plugin);

    }

    plugins

}

        let operation_name = params.operation_name();

        let modeled_auth_options = match self.operation_overrides.get(operation_name) {

            Some(overrides) => overrides,

            None => &self.service_defaults,

        };

        let _fut = ::aws_smithy_runtime_api::client::auth::AuthSchemeOptionsFuture::ready(Ok(modeled_auth_options.clone()));

        _fut

    }

}

/// Configuration parameters for resolving the correct auth scheme

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

pub struct Params {

    operation_name: ::std::borrow::Cow<'static, str>,

}

impl Params {

    /// Create a builder for [`Params`]

    /// Set the operation name for the builder

    pub fn set_operation_name(mut self, operation_name: ::std::option::Option<::std::borrow::Cow<'static, str>>) -> Self {

        self.operation_name = operation_name;

        self

    }

    /// Consume this builder, create [`Params`]."

    ///

    /// Return [`BuildError`] if any of the required fields are unset.

    ///

    pub fn build(self) -> ::std::result::Result<crate::config::auth::Params, crate::config::auth::BuildError> {

        ::std::result::Result::Ok(crate::config::auth::Params {

            operation_name: self.operation_name.ok_or_else(|| BuildError::missing("operation_name"))?,

        })

    }

}

/// An error that occurred while constructing `config::auth::Params`

#[derive(Debug)]

pub struct BuildError {

        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<EnumQueryInput>()

            .ok_or("failed to downcast to EnumQueryInput")?;

        let params = crate::config::endpoint::Params::builder().build().map_err(|err| {

            ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

        })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

#[allow(unreachable_code, unused_variables)]

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/foo/enumvalue", "path was incorrect");

    }

    /// Upper case error modeled lower case

    /// Test ID: ServiceLevelErrorClient

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn service_level_error_client_response() {

        let expected_output = crate::types::error::ExtraError::builder().build();

        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(

            ::http::response::Builder::new()

                .header("X-Amzn-Errortype", "ExtraError")

                .status(500)

                .body(::aws_smithy_types::body::SdkBody::from(""))