Client Test

pub use crate::operation::constant_query_string::_constant_query_string_output::ConstantQueryStringOutputBuilder;

pub use crate::operation::content_type_parameters::_content_type_parameters_output::ContentTypeParametersOutput;

pub use crate::operation::content_type_parameters::_content_type_parameters_output::ContentTypeParametersOutputBuilder;

pub use crate::operation::datetime_offsets::_datetime_offsets_output::DatetimeOffsetsOutput;

pub use crate::operation::datetime_offsets::_datetime_offsets_output::DatetimeOffsetsOutputBuilder;

pub use crate::operation::document_type::_document_type_output::DocumentTypeOutput;

pub use crate::operation::document_type::_document_type_output::DocumentTypeOutputBuilder;

pub use crate::operation::document_type_as_map_value::_document_type_as_map_value_output::DocumentTypeAsMapValueOutput;

pub use crate::operation::document_type_as_map_value::_document_type_as_map_value_output::DocumentTypeAsMapValueOutputBuilder;

pub use crate::operation::document_type_as_payload::_document_type_as_payload_output::DocumentTypeAsPayloadOutput;

pub use crate::operation::document_type_as_payload::_document_type_as_payload_output::DocumentTypeAsPayloadOutputBuilder;

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

/// Orchestration and serialization glue logic for `DuplexStream`.

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

#[non_exhaustive]

pub struct DuplexStream;

impl DuplexStream {

    /// Creates a new `DuplexStream`

    pub fn new() -> Self {

        Self

    }

    pub(crate) async fn orchestrate(

        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,

        input: crate::operation::duplex_stream::DuplexStreamInput,

    ) -> ::std::result::Result<

        crate::operation::duplex_stream::DuplexStreamOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::duplex_stream::DuplexStreamError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >| {

            err.map_service_error(|err| {

                err.downcast::<crate::operation::duplex_stream::DuplexStreamError>()

                    .expect("correct error type")

            })

        };

        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)

            .await

            .map_err(map_err)?;

        let output = context.finalize().map_err(map_err)?;

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

            output

                .downcast::<crate::operation::duplex_stream::DuplexStreamOutput>()

                .expect("correct output type"),

        )

    }

    pub(crate) async fn orchestrate_with_stop_point(

        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,

        input: crate::operation::duplex_stream::DuplexStreamInput,

        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,

    ) -> ::std::result::Result<

        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,

        ::aws_smithy_runtime_api::client::result::SdkError<

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);

        use ::tracing::Instrument;

        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("Rest Json Protocol", "DuplexStream", input, runtime_plugins, stop_point)

            // Create a parent span for the entire operation. Includes a random, internal-only,

            // seven-digit ID for the operation orchestration so that it can be correlated in the logs.

            .instrument(::tracing::debug_span!(

                "Rest Json Protocol.DuplexStream",

                "rpc.service" = "Rest Json Protocol",

                "rpc.method" = "DuplexStream",

                "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),

            ))

            .await

    }

    pub(crate) fn operation_runtime_plugins(

        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,

        client_config: &crate::config::Config,

        config_override: ::std::option::Option<crate::config::Builder>,

    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {

        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());

        if let ::std::option::Option::Some(config_override) = config_override {

            for plugin in config_override.runtime_plugins.iter().cloned() {

                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);

            }

            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(

                config_override,

                client_config.config.clone(),

                &client_config.runtime_components,

            ));

        }

        runtime_plugins

    }

}

impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for DuplexStream {

    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {

        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("DuplexStream");

        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(

            DuplexStreamRequestSerializer,

        ));

        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(

            DuplexStreamResponseDeserializer,

        ));

        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(

            crate::config::auth::Params::builder()

                .operation_name("DuplexStream")

                .build()

                .expect("required fields set"),

        ));

        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(

            "DuplexStream",

            "Rest Json Protocol",

        ));

        ::std::option::Option::Some(cfg.freeze())

    }

    fn runtime_components(

        &self,

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

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

        #[allow(unused_mut)]

        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DuplexStream")

            .with_interceptor(DuplexStreamEndpointParamsInterceptor)

            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<

                crate::operation::duplex_stream::DuplexStreamError,

            >::new())

            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                crate::operation::duplex_stream::DuplexStreamError,

            >::new());

        ::std::borrow::Cow::Owned(rcb)

    }

}

#[derive(Debug)]

struct DuplexStreamResponseDeserializer;

impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DuplexStreamResponseDeserializer {

    fn deserialize_streaming(

        &self,

        response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

    ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {

        #[allow(unused_mut)]

        let mut force_error = false;

        // If this is an error, defer to the non-streaming parser

        if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {

            return ::std::option::Option::None;

        }

        ::std::option::Option::Some(crate::protocol_serde::type_erase_result(

            crate::protocol_serde::shape_duplex_stream::de_duplex_stream_http_response(response),

        ))

    }

    fn deserialize_nonstreaming(

        &self,

        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {

        // For streaming operations, we only hit this case if its an error

        let body = response.body().bytes().expect("body loaded");

        crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_duplex_stream::de_duplex_stream_http_error(

            response.status().as_u16(),

            response.headers(),

            body,

        ))

    }

}

#[derive(Debug)]

struct DuplexStreamRequestSerializer;

impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DuplexStreamRequestSerializer {

    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]

    fn serialize_input(

        &self,

        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,

        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,

    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {

        let input = input

            .downcast::<crate::operation::duplex_stream::DuplexStreamInput>()

            .expect("correct type");

        let _header_serialization_settings = _cfg

            .load::<crate::serialization_settings::HeaderSerializationSettings>()

            .cloned()

            .unwrap_or_default();

        let mut request_builder = {

            #[allow(clippy::uninlined_format_args)]

            fn uri_base(

                _input: &crate::operation::duplex_stream::DuplexStreamInput,

                output: &mut ::std::string::String,

            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {

                use ::std::fmt::Write as _;

                ::std::write!(output, "/DuplexStream").expect("formatting should succeed");

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

            }

            #[allow(clippy::unnecessary_wraps)]

            fn update_http_builder(

                input: &crate::operation::duplex_stream::DuplexStreamInput,

                builder: ::http_1x::request::Builder,

            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {

                let mut uri = ::std::string::String::new();

                uri_base(input, &mut uri)?;

                ::std::result::Result::Ok(builder.method("POST").uri(uri))

            }

            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;

            builder =

                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");

            builder

        };

        let body = ::aws_smithy_types::body::SdkBody::from({

            let error_marshaller = crate::event_stream_serde::EventStreamErrorMarshaller::new();

            let marshaller = crate::event_stream_serde::EventStreamMarshaller::new();

            let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();

            _cfg.interceptor_state().store_put(signer_sender);

            ::aws_smithy_types::body::SdkBody::from_body_1_x(::http_body_util::StreamBody::new(input.stream.into_body_stream(

                marshaller,

                error_marshaller,

                signer,

            )))

        });

        if let Some(content_length) = body.content_length() {

            let content_length = content_length.to_string();

            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);

        }

        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

    }

}

#[derive(Debug)]

struct DuplexStreamEndpointParamsInterceptor;

impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DuplexStreamEndpointParamsInterceptor {

    fn name(&self) -> &'static str {

        "DuplexStreamEndpointParamsInterceptor"

    }

    fn read_before_execution(

        &self,

        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<

            '_,

            ::aws_smithy_runtime_api::client::interceptors::context::Input,

            ::aws_smithy_runtime_api::client::interceptors::context::Output,

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

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

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

        let _input = context

            .input()

            .downcast_ref::<DuplexStreamInput>()

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

        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.

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

#[non_exhaustive]

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

pub enum DuplexStreamError {

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

    ErrorEvent(crate::types::error::ErrorEvent),

    /// 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-DuplexStreamError) for what information is available for the error.")]

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

}

impl DuplexStreamError {

    /// Creates the `DuplexStreamError::Unhandled` variant from any error type.

    pub fn unhandled(

        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,

    ) -> Self {

        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {

            source: err.into(),

            meta: ::std::default::Default::default(),

        })

    }

    /// Creates the `DuplexStreamError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).

    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {

        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {

            source: err.clone().into(),

            meta: err,

        })

    }

    ///

    /// Returns error metadata, which includes the error code, message,

    /// request ID, and potentially additional information.

    ///

    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {

        match self {

            Self::ErrorEvent(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),

            Self::Unhandled(e) => &e.meta,

        }

    }

    /// Returns `true` if the error kind is `DuplexStreamError::ErrorEvent`.

    pub fn is_error_event(&self) -> bool {

        matches!(self, Self::ErrorEvent(_))

    }

}

impl ::std::error::Error for DuplexStreamError {

    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {

        match self {

            Self::ErrorEvent(_inner) => ::std::option::Option::Some(_inner),

            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),

        }

    }

}

impl ::std::fmt::Display for DuplexStreamError {

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

        match self {

            Self::ErrorEvent(_inner) => _inner.fmt(f),

            Self::Unhandled(_inner) => {

                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {

                    write!(f, "unhandled error ({code})")

                } else {

                    f.write_str("unhandled error")

                }

            }

        }

    }

}

impl ::aws_smithy_types::retry::ProvideErrorKind for DuplexStreamError {

    fn code(&self) -> ::std::option::Option<&str> {

        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)

    }

    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {

        ::std::option::Option::None

    }

}

impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for DuplexStreamError {

    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {

        match self {

            Self::ErrorEvent(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),

            Self::Unhandled(_inner) => &_inner.meta,

        }

    }

}

impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for DuplexStreamError {

    fn create_unhandled_error(

        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,

        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,

    ) -> Self {

        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {

            source,

            meta: meta.unwrap_or_default(),

        })

    }

}

pub use crate::operation::duplex_stream::_duplex_stream_input::DuplexStreamInput;

pub use crate::operation::duplex_stream::_duplex_stream_output::DuplexStreamOutput;

mod _duplex_stream_input;

mod _duplex_stream_output;

/// Builders

pub mod builders;

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

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

#[non_exhaustive]

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

pub struct DuplexStreamInput {

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

    pub stream: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,

}

impl DuplexStreamInput {

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

    pub fn stream(&self) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError> {

        &self.stream

    }

}

impl DuplexStreamInput {

    /// Creates a new builder-style object to manufacture [`DuplexStreamInput`](crate::operation::duplex_stream::DuplexStreamInput).

    pub fn builder() -> crate::operation::duplex_stream::builders::DuplexStreamInputBuilder {

        crate::operation::duplex_stream::builders::DuplexStreamInputBuilder::default()

    }

}

/// A builder for [`DuplexStreamInput`](crate::operation::duplex_stream::DuplexStreamInput).

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

#[non_exhaustive]

pub struct DuplexStreamInputBuilder {

    pub(crate) stream:

        ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>>,

}

impl DuplexStreamInputBuilder {

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

    pub fn stream(

        mut self,

        input: ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,

    ) -> Self {

        self.stream = ::std::option::Option::Some(input);

        self

    }

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

    pub fn set_stream(

        mut self,

        input: ::std::option::Option<

            ::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>,

        >,

    ) -> Self {

        self.stream = input;

        self

    }

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

    pub fn get_stream(

        &self,

    ) -> &::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::EventStream, crate::types::error::EventStreamError>>

    {

        &self.stream

    }

    /// Consumes the builder and constructs a [`DuplexStreamInput`](crate::operation::duplex_stream::DuplexStreamInput).

    /// This method will fail if any of the following fields are not set:

    /// - [`stream`](crate::operation::duplex_stream::builders::DuplexStreamInputBuilder::stream)

    pub fn build(

        self,

    ) -> ::std::result::Result<crate::operation::duplex_stream::DuplexStreamInput, ::aws_smithy_types::error::operation::BuildError> {

        ::std::result::Result::Ok(crate::operation::duplex_stream::DuplexStreamInput {

            stream: self.stream.ok_or_else(|| {

                ::aws_smithy_types::error::operation::BuildError::missing_field(

                    "stream",

                    "stream was not specified but it is required when building DuplexStreamInput",

                )

            })?,

        })

    }

}

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

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

#[non_exhaustive]

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

pub struct DuplexStreamOutput {

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

    pub stream: crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>,

}

impl DuplexStreamOutput {

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

    pub fn stream(&self) -> &crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError> {

        &self.stream

    }

}

impl DuplexStreamOutput {

    /// Creates a new builder-style object to manufacture [`DuplexStreamOutput`](crate::operation::duplex_stream::DuplexStreamOutput).

    pub fn builder() -> crate::operation::duplex_stream::builders::DuplexStreamOutputBuilder {

        crate::operation::duplex_stream::builders::DuplexStreamOutputBuilder::default()

    }

}

/// A builder for [`DuplexStreamOutput`](crate::operation::duplex_stream::DuplexStreamOutput).

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

#[non_exhaustive]

pub struct DuplexStreamOutputBuilder {

    pub(crate) stream: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>>,

}

impl DuplexStreamOutputBuilder {

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

    pub fn stream(mut self, input: crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>) -> Self {

        self.stream = ::std::option::Option::Some(input);

        self

    }

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

    pub fn set_stream(

        mut self,

        input: ::std::option::Option<crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>>,

    ) -> Self {

        self.stream = input;

        self

    }

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

    pub fn get_stream(

        &self,

    ) -> &::std::option::Option<crate::event_receiver::EventReceiver<crate::types::EventStream, crate::types::error::EventStreamError>> {

        &self.stream

    }

    /// Consumes the builder and constructs a [`DuplexStreamOutput`](crate::operation::duplex_stream::DuplexStreamOutput).

    /// This method will fail if any of the following fields are not set:

    /// - [`stream`](crate::operation::duplex_stream::builders::DuplexStreamOutputBuilder::stream)

    pub fn build(

        self,

    ) -> ::std::result::Result<crate::operation::duplex_stream::DuplexStreamOutput, ::aws_smithy_types::error::operation::BuildError> {

        ::std::result::Result::Ok(crate::operation::duplex_stream::DuplexStreamOutput {

            stream: self.stream.ok_or_else(|| {

                ::aws_smithy_types::error::operation::BuildError::missing_field(

                    "stream",

                    "stream was not specified but it is required when building DuplexStreamOutput",

                )

            })?,

        })

    }

}

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

pub use crate::operation::duplex_stream::_duplex_stream_input::DuplexStreamInputBuilder;

pub use crate::operation::duplex_stream::_duplex_stream_output::DuplexStreamOutputBuilder;

impl crate::operation::duplex_stream::builders::DuplexStreamInputBuilder {

    /// Sends a request with this input using the given client.

    pub async fn send_with(

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::duplex_stream::DuplexStreamOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::duplex_stream::DuplexStreamError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.duplex_stream();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `DuplexStream`.

///

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

pub struct DuplexStreamFluentBuilder {

    handle: ::std::sync::Arc<crate::client::Handle>,

    inner: crate::operation::duplex_stream::builders::DuplexStreamInputBuilder,

    config_override: ::std::option::Option<crate::config::Builder>,

}

impl

    crate::client::customize::internal::CustomizableSend<

        crate::operation::duplex_stream::DuplexStreamOutput,

        crate::operation::duplex_stream::DuplexStreamError,

    > for DuplexStreamFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::duplex_stream::DuplexStreamOutput,

            crate::operation::duplex_stream::DuplexStreamError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl DuplexStreamFluentBuilder {

    /// Creates a new `DuplexStreamFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

            config_override: ::std::option::Option::None,

        }

    }

    /// Access the DuplexStream as a reference.

    pub fn as_input(&self) -> &crate::operation::duplex_stream::builders::DuplexStreamInputBuilder {

        &self.inner

    }

    /// Sends the request and returns the response.

    ///

    /// If an error occurs, an `SdkError` will be returned with additional details that