// @generated by Thrift for thrift/compiler/test/fixtures/interactions/src/module.thrift
// This file is probably not the place you want to edit!

//! Client implementation for each service in `module`.

#![recursion_limit = "100000000"]
#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals, unused_crate_dependencies, unused_imports, clippy::all)]


#[doc(inline)]
pub use :: as types;

pub mod errors;

pub(crate) use crate as client;
pub(crate) use ::::services;

pub trait MyInteraction: ::std::marker::Send {
    fn frobnicate(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>>;

    fn ping(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>>;

    fn truthify(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>>;

}

pub trait MyInteractionExt<T>: MyInteraction
where
    T: ::fbthrift::Transport,
{
    fn frobnicate_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>>;
    fn ping_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>>;
    fn truthify_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> MyInteraction for S
where
    S: ::std::convert::AsRef<dyn MyInteraction + 'a>,
    S: ::std::marker::Send,
{
    fn frobnicate(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
        self.as_ref().frobnicate(
        )
    }
    fn ping(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
        self.as_ref().ping(
        )
    }
    fn truthify(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
        self.as_ref().truthify(
        )
    }
}

#[allow(deprecated)]
impl<'a, S, T> MyInteractionExt<T> for S
where
    S: ::std::convert::AsRef<dyn MyInteraction + 'a> + ::std::convert::AsRef<dyn MyInteractionExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn frobnicate_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
        <Self as ::std::convert::AsRef<dyn MyInteractionExt<T>>>::as_ref(self).frobnicate_with_rpc_opts(
            rpc_options,
        )
    }
    fn ping_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
        <Self as ::std::convert::AsRef<dyn MyInteractionExt<T>>>::as_ref(self).ping_with_rpc_opts(
            rpc_options,
        )
    }
    fn truthify_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
        <Self as ::std::convert::AsRef<dyn MyInteractionExt<T>>>::as_ref(self).truthify_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}pub trait MyInteractionFast: ::std::marker::Send {
    fn frobnicate(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>>;

    fn ping(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>>;

    fn truthify(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>>;

}

pub trait MyInteractionFastExt<T>: MyInteractionFast
where
    T: ::fbthrift::Transport,
{
    fn frobnicate_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>>;
    fn ping_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>>;
    fn truthify_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> MyInteractionFast for S
where
    S: ::std::convert::AsRef<dyn MyInteractionFast + 'a>,
    S: ::std::marker::Send,
{
    fn frobnicate(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
        self.as_ref().frobnicate(
        )
    }
    fn ping(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
        self.as_ref().ping(
        )
    }
    fn truthify(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
        self.as_ref().truthify(
        )
    }
}

#[allow(deprecated)]
impl<'a, S, T> MyInteractionFastExt<T> for S
where
    S: ::std::convert::AsRef<dyn MyInteractionFast + 'a> + ::std::convert::AsRef<dyn MyInteractionFastExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn frobnicate_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
        <Self as ::std::convert::AsRef<dyn MyInteractionFastExt<T>>>::as_ref(self).frobnicate_with_rpc_opts(
            rpc_options,
        )
    }
    fn ping_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
        <Self as ::std::convert::AsRef<dyn MyInteractionFastExt<T>>>::as_ref(self).ping_with_rpc_opts(
            rpc_options,
        )
    }
    fn truthify_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
        <Self as ::std::convert::AsRef<dyn MyInteractionFastExt<T>>>::as_ref(self).truthify_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}pub trait SerialInteraction: ::std::marker::Send {
    fn frobnicate(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>>;
}

pub trait SerialInteractionExt<T>: SerialInteraction
where
    T: ::fbthrift::Transport,
{
    fn frobnicate_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> SerialInteraction for S
where
    S: ::std::convert::AsRef<dyn SerialInteraction + 'a>,
    S: ::std::marker::Send,
{
    fn frobnicate(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
        self.as_ref().frobnicate(
        )
    }
}

#[allow(deprecated)]
impl<'a, S, T> SerialInteractionExt<T> for S
where
    S: ::std::convert::AsRef<dyn SerialInteraction + 'a> + ::std::convert::AsRef<dyn SerialInteractionExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn frobnicate_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
        <Self as ::std::convert::AsRef<dyn SerialInteractionExt<T>>>::as_ref(self).frobnicate_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}

pub mod my_service {
    use super::*;
    
    
    /// Client definitions for `MyInteraction`.
    pub struct MyInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.MyInteraction.frobnicate";
            let args = self::Args_MyInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.MyInteraction.ping";
            let args = self::Args_MyInteraction_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.MyInteraction.truthify";
            let args = self::Args_MyInteraction_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteraction.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteraction for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionExt<T> for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionDynClient = dyn MyInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionClient = ::std::sync::Arc<MyInteractionDynClient>;
    
    
        
    
    /// Client definitions for `MyInteractionFast`.
    pub struct MyInteractionFastImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.MyInteractionFast.frobnicate";
            let args = self::Args_MyInteractionFast_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteractionFast.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction_fast::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.MyInteractionFast.ping";
            let args = self::Args_MyInteractionFast_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteractionFast.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction_fast::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.MyInteractionFast.truthify";
            let args = self::Args_MyInteractionFast_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteractionFast.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction_fast::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction_fast::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction_fast::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionFastImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteractionFast_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteractionFast_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteractionFast_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteractionFast for MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionFastExt<T> for MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionFastDynClient = dyn MyInteractionFast + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionFastClient = ::std::sync::Arc<MyInteractionFastDynClient>;
    
    
        
    
    /// Client definitions for `SerialInteraction`.
    pub struct SerialInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.SerialInteraction.frobnicate";
            let args = self::Args_SerialInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("SerialInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "SerialInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::serial_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::serial_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "SerialInteraction.frobnicate"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for SerialInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_SerialInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_SerialInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "SerialInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> SerialInteraction for SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> SerialInteractionExt<T> for SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type SerialInteractionDynClient = dyn SerialInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type SerialInteractionClient = ::std::sync::Arc<SerialInteractionDynClient>;
    
    
    
}

pub trait MyService: ::std::marker::Send {
    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::MyInteractionClient, ::anyhow::Error>;

    fn createMyInteractionFast(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::MyInteractionFastClient, ::anyhow::Error>;

    fn createSerialInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::SerialInteractionClient, ::anyhow::Error>;

    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>>;

    fn interact(
        &self,
        arg_arg: ::std::primitive::i32,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>>;

    fn interactFast(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>>;

    fn serialize(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>>;
}

pub trait MyServiceExt<T>: MyService
where
    T: ::fbthrift::Transport,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>>;
    fn interact_with_rpc_opts(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>>;
    fn interactFast_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>>;
    fn serialize_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> MyService for S
where
    S: ::std::convert::AsRef<dyn MyService + 'a>,
    S: ::std::marker::Send,
{
    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::MyInteractionClient, ::anyhow::Error> {
        self.as_ref().createMyInteraction()
    }
    fn createMyInteractionFast(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::MyInteractionFastClient, ::anyhow::Error> {
        self.as_ref().createMyInteractionFast()
    }
    fn createSerialInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::SerialInteractionClient, ::anyhow::Error> {
        self.as_ref().createSerialInteraction()
    }
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>> {
        self.as_ref().foo(
        )
    }
    fn interact(
        &self,
        arg_arg: ::std::primitive::i32,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>> {
        self.as_ref().interact(
            arg_arg,
        )
    }
    fn interactFast(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>> {
        self.as_ref().interactFast(
        )
    }
    fn serialize(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>> {
        self.as_ref().serialize(
        )
    }
}

#[allow(deprecated)]
impl<'a, S, T> MyServiceExt<T> for S
where
    S: ::std::convert::AsRef<dyn MyService + 'a> + ::std::convert::AsRef<dyn MyServiceExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>> {
        <Self as ::std::convert::AsRef<dyn MyServiceExt<T>>>::as_ref(self).foo_with_rpc_opts(
            rpc_options,
        )
    }
    fn interact_with_rpc_opts(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>> {
        <Self as ::std::convert::AsRef<dyn MyServiceExt<T>>>::as_ref(self).interact_with_rpc_opts(
            arg_arg,
            rpc_options,
        )
    }
    fn interactFast_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>> {
        <Self as ::std::convert::AsRef<dyn MyServiceExt<T>>>::as_ref(self).interactFast_with_rpc_opts(
            rpc_options,
        )
    }
    fn serialize_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>> {
        <Self as ::std::convert::AsRef<dyn MyServiceExt<T>>>::as_ref(self).serialize_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}
/// Client definitions for `MyService`.
pub struct MyServiceImpl<P, T, S = ::fbthrift::NoopSpawner> {
    transport: T,
    _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
}

impl<P, T, S> MyServiceImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    pub fn new(
        transport: T,
    ) -> Self {
        Self {
            transport,
            _phantom: ::std::marker::PhantomData,
        }
    }

    pub fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }


    fn _foo_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.foo";
        let args = self::Args_MyService_foo {
            _phantom: ::std::marker::PhantomData,
        };

        let transport = self.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("foo", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "MyService.foo"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_service::FooReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::my_service::FooError::ApplicationException(aexn))
                }
            };
            res
        }
        .instrument(::tracing::info_span!("stream", method = "MyService.foo"))
        .boxed()
    }

    fn _interact_impl(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.interact";
        const INTERACTION_NAME: &::std::ffi::CStr = c"MyInteraction";
        let args = self::Args_MyService_interact {
            arg: arg_arg,
            _phantom: ::std::marker::PhantomData,
        };

        let interaction_transport = match self.transport().create_interaction(INTERACTION_NAME) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };
        let interaction_impl = crate::my_service::MyInteractionImpl::<P, T, S>::new(interaction_transport);
        let transport = interaction_impl.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("interact", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "MyService.interact"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_service::InteractReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::my_service::InteractError::ApplicationException(aexn))
                }
            };
            let interaction_client: crate::client::my_service::MyInteractionClient = ::std::sync::Arc::new(interaction_impl);
            res?;
            ::std::result::Result::Ok(interaction_client)
        }
        .instrument(::tracing::info_span!("stream", method = "MyService.interact"))
        .boxed()
    }

    fn _interactFast_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.interactFast";
        const INTERACTION_NAME: &::std::ffi::CStr = c"MyInteractionFast";
        let args = self::Args_MyService_interactFast {
            _phantom: ::std::marker::PhantomData,
        };

        let interaction_transport = match self.transport().create_interaction(INTERACTION_NAME) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };
        let interaction_impl = crate::my_service::MyInteractionFastImpl::<P, T, S>::new(interaction_transport);
        let transport = interaction_impl.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("interactFast", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "MyService.interactFast"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_service::InteractFastReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::my_service::InteractFastError::ApplicationException(aexn))
                }
            };
            let interaction_client: crate::client::my_service::MyInteractionFastClient = ::std::sync::Arc::new(interaction_impl);
            ::std::result::Result::Ok((interaction_client, res?))
        }
        .instrument(::tracing::info_span!("stream", method = "MyService.interactFast"))
        .boxed()
    }

    fn _serialize_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;
        use ::futures::StreamExt as _;
        use ::fbthrift::Deserialize as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"MyService";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"MyService.serialize";
        const INTERACTION_NAME: &::std::ffi::CStr = c"SerialInteraction";
        let args = self::Args_MyService_serialize {
            _phantom: ::std::marker::PhantomData,
        };

        let interaction_transport = match self.transport().create_interaction(INTERACTION_NAME) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };
        let interaction_impl = crate::my_service::SerialInteractionImpl::<P, T, S>::new(interaction_transport);
        let transport = interaction_impl.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("serialize", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call_stream = transport
            .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call_stream", method = "MyService.serialize"));

        async move {
            let (initial, stream) = call_stream.await?;

            let new_stream = stream.then(|item_res| {
                async move {
                    match item_res {
                        ::std::result::Result::Err(err) =>
                            ::std::result::Result::Err(crate::errors::my_service::SerializeStreamError::from(err)),
                        ::std::result::Result::Ok(item_enc) => {
                            S::spawn(move || {
                                match item_enc {
                                    ::fbthrift::ClientStreamElement::Reply(payload) => {
                                        let mut de = P::deserializer(payload);
                                        <crate::errors::my_service::SerializeStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                    }
                                    ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                        let mut de = P::deserializer(payload);
                                        let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                        ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_service::SerializeStreamError::ApplicationException(aexn)))
                                    }
                                }
                            }).await.map_err(::anyhow::Error::from)??
                        }
                    }
                }
            })
            .boxed();

            let de = P::deserializer(initial);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_service::SerializeReader, S>(de)
                .await??
                .map(move |initial| (initial, new_stream));
            let interaction_client: crate::client::my_service::SerialInteractionClient = ::std::sync::Arc::new(interaction_impl);
            ::std::result::Result::Ok((interaction_client, res?))
        }
        .instrument(::tracing::info_span!("stream", method = "MyService.serialize"))
        .boxed()
    }
}

impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyServiceImpl<P, T, S>
where
    T: ::fbthrift::Transport,
{
    fn transport(&self) -> &T {
        &self.transport
    }
}



struct Args_MyService_foo<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyService_foo<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyService.foo"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

struct Args_MyService_interact<'a> {
    arg: ::std::primitive::i32,
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyService_interact<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyService.interact"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_begin("arg", ::fbthrift::TType::I32, 1i16);
        ::fbthrift::Serialize::write(&self.arg, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

struct Args_MyService_interactFast<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyService_interactFast<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyService.interactFast"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

struct Args_MyService_serialize<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyService_serialize<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyService.serialize"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P, T, S> MyService for MyServiceImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{

    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::MyInteractionClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::my_service::MyInteractionImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"MyInteraction")?
                )
            )
        )
    }

    fn createMyInteractionFast(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::MyInteractionFastClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::my_service::MyInteractionFastImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"MyInteractionFast")?
                )
            )
        )
    }

    fn createSerialInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::my_service::SerialInteractionClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::my_service::SerialInteractionImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"SerialInteraction")?
                )
            )
        )
    }
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>> {
        let rpc_options = T::RpcOptions::default();
        self._foo_impl(
            rpc_options,
        )
    }
    fn interact(
        &self,
        arg_arg: ::std::primitive::i32,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>> {
        let rpc_options = T::RpcOptions::default();
        self._interact_impl(
            arg_arg,
            rpc_options,
        )
    }
    fn interactFast(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>> {
        let rpc_options = T::RpcOptions::default();
        self._interactFast_impl(
            rpc_options,
        )
    }
    fn serialize(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>> {
        let rpc_options = T::RpcOptions::default();
        self._serialize_impl(
            rpc_options,
        )
    }
}

impl<P, T, S> MyServiceExt<T> for MyServiceImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_service::FooError>> {
        self._foo_impl(
            rpc_options,
        )
    }
    fn interact_with_rpc_opts(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::my_service::MyInteractionClient, crate::errors::my_service::InteractError>> {
        self._interact_impl(
            arg_arg,
            rpc_options,
        )
    }
    fn interactFast_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::MyInteractionFastClient, ::std::primitive::i32), crate::errors::my_service::InteractFastError>> {
        self._interactFast_impl(
            rpc_options,
        )
    }
    fn serialize_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::my_service::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_service::SerializeStreamError>>)), crate::errors::my_service::SerializeError>> {
        self._serialize_impl(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        self.transport()
    }
}

#[derive(Clone)]
pub struct make_MyService;

/// To be called by user directly setting up a client. Avoids
/// needing ClientFactory trait in scope, avoids unidiomatic
/// make_Trait name.
///
/// ```
/// # const _: &str = stringify! {
/// use bgs::client::BuckGraphService;
///
/// let protocol = BinaryProtocol::new();
/// let transport = HttpClient::new();
/// let client = <dyn BuckGraphService>::new(protocol, transport);
/// # };
/// ```
impl dyn MyService {
    pub fn new<P, T>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl MyService + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, T, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl MyService + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(MyServiceImpl::<P, T, S>::new(transport))
    }
}

impl<T> dyn MyServiceExt<T>
where
    T: ::fbthrift::Transport,
{
    pub fn new<P>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl MyServiceExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl MyServiceExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(MyServiceImpl::<P, T, S>::new(transport))
    }
}

pub type MyServiceDynClient = <make_MyService as ::fbthrift::ClientFactory>::Api;
pub type MyServiceClient = ::std::sync::Arc<MyServiceDynClient>;

/// The same thing, but to be called from generic contexts where we are
/// working with a type parameter `C: ClientFactory` to produce clients.
impl ::fbthrift::ClientFactory for make_MyService {
    type Api = dyn MyService + ::std::marker::Send + ::std::marker::Sync + 'static;

    fn with_spawner<P, T, S>(protocol: P, transport: T, spawner: S) -> ::std::sync::Arc<Self::Api>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        <dyn MyService>::with_spawner(protocol, transport, spawner)
    }
}


pub mod factories {
    use super::*;
    
    
    /// Client definitions for `MyInteraction`.
    pub struct MyInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.MyInteraction.frobnicate";
            let args = self::Args_MyInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.MyInteraction.ping";
            let args = self::Args_MyInteraction_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.MyInteraction.truthify";
            let args = self::Args_MyInteraction_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteraction.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteraction for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionExt<T> for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionDynClient = dyn MyInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionClient = ::std::sync::Arc<MyInteractionDynClient>;
    
    
        
    
    /// Client definitions for `MyInteractionFast`.
    pub struct MyInteractionFastImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.MyInteractionFast.frobnicate";
            let args = self::Args_MyInteractionFast_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteractionFast.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction_fast::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.MyInteractionFast.ping";
            let args = self::Args_MyInteractionFast_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteractionFast.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction_fast::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.MyInteractionFast.truthify";
            let args = self::Args_MyInteractionFast_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteractionFast.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction_fast::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction_fast::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction_fast::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionFastImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteractionFast_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteractionFast_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteractionFast_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteractionFast for MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionFastExt<T> for MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionFastDynClient = dyn MyInteractionFast + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionFastClient = ::std::sync::Arc<MyInteractionFastDynClient>;
    
    
        
    
    /// Client definitions for `SerialInteraction`.
    pub struct SerialInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.SerialInteraction.frobnicate";
            let args = self::Args_SerialInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("SerialInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "SerialInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::serial_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::serial_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "SerialInteraction.frobnicate"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for SerialInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_SerialInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_SerialInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "SerialInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> SerialInteraction for SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> SerialInteractionExt<T> for SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type SerialInteractionDynClient = dyn SerialInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type SerialInteractionClient = ::std::sync::Arc<SerialInteractionDynClient>;
    
    
    
}

pub trait Factories: ::std::marker::Send {
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>>;

    fn interact(
        &self,
        arg_arg: ::std::primitive::i32,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>>;

    fn interactFast(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>>;

    fn serialize(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>>;
}

pub trait FactoriesExt<T>: Factories
where
    T: ::fbthrift::Transport,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>>;
    fn interact_with_rpc_opts(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>>;
    fn interactFast_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>>;
    fn serialize_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> Factories for S
where
    S: ::std::convert::AsRef<dyn Factories + 'a>,
    S: ::std::marker::Send,
{
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>> {
        self.as_ref().foo(
        )
    }
    fn interact(
        &self,
        arg_arg: ::std::primitive::i32,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>> {
        self.as_ref().interact(
            arg_arg,
        )
    }
    fn interactFast(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>> {
        self.as_ref().interactFast(
        )
    }
    fn serialize(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>> {
        self.as_ref().serialize(
        )
    }
}

#[allow(deprecated)]
impl<'a, S, T> FactoriesExt<T> for S
where
    S: ::std::convert::AsRef<dyn Factories + 'a> + ::std::convert::AsRef<dyn FactoriesExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>> {
        <Self as ::std::convert::AsRef<dyn FactoriesExt<T>>>::as_ref(self).foo_with_rpc_opts(
            rpc_options,
        )
    }
    fn interact_with_rpc_opts(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>> {
        <Self as ::std::convert::AsRef<dyn FactoriesExt<T>>>::as_ref(self).interact_with_rpc_opts(
            arg_arg,
            rpc_options,
        )
    }
    fn interactFast_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>> {
        <Self as ::std::convert::AsRef<dyn FactoriesExt<T>>>::as_ref(self).interactFast_with_rpc_opts(
            rpc_options,
        )
    }
    fn serialize_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>> {
        <Self as ::std::convert::AsRef<dyn FactoriesExt<T>>>::as_ref(self).serialize_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}
/// Client definitions for `Factories`.
pub struct FactoriesImpl<P, T, S = ::fbthrift::NoopSpawner> {
    transport: T,
    _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
}

impl<P, T, S> FactoriesImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    pub fn new(
        transport: T,
    ) -> Self {
        Self {
            transport,
            _phantom: ::std::marker::PhantomData,
        }
    }

    pub fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }


    fn _foo_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.foo";
        let args = self::Args_Factories_foo {
            _phantom: ::std::marker::PhantomData,
        };

        let transport = self.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("foo", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "Factories.foo"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::factories::FooReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::factories::FooError::ApplicationException(aexn))
                }
            };
            res
        }
        .instrument(::tracing::info_span!("stream", method = "Factories.foo"))
        .boxed()
    }

    fn _interact_impl(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.interact";
        const INTERACTION_NAME: &::std::ffi::CStr = c"MyInteraction";
        let args = self::Args_Factories_interact {
            arg: arg_arg,
            _phantom: ::std::marker::PhantomData,
        };

        let interaction_transport = match self.transport().create_interaction(INTERACTION_NAME) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };
        let interaction_impl = crate::factories::MyInteractionImpl::<P, T, S>::new(interaction_transport);
        let transport = interaction_impl.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("interact", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "Factories.interact"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::factories::InteractReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::factories::InteractError::ApplicationException(aexn))
                }
            };
            let interaction_client: crate::client::factories::MyInteractionClient = ::std::sync::Arc::new(interaction_impl);
            res?;
            ::std::result::Result::Ok(interaction_client)
        }
        .instrument(::tracing::info_span!("stream", method = "Factories.interact"))
        .boxed()
    }

    fn _interactFast_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.interactFast";
        const INTERACTION_NAME: &::std::ffi::CStr = c"MyInteractionFast";
        let args = self::Args_Factories_interactFast {
            _phantom: ::std::marker::PhantomData,
        };

        let interaction_transport = match self.transport().create_interaction(INTERACTION_NAME) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };
        let interaction_impl = crate::factories::MyInteractionFastImpl::<P, T, S>::new(interaction_transport);
        let transport = interaction_impl.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("interactFast", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "Factories.interactFast"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::factories::InteractFastReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::factories::InteractFastError::ApplicationException(aexn))
                }
            };
            let interaction_client: crate::client::factories::MyInteractionFastClient = ::std::sync::Arc::new(interaction_impl);
            ::std::result::Result::Ok((interaction_client, res?))
        }
        .instrument(::tracing::info_span!("stream", method = "Factories.interactFast"))
        .boxed()
    }

    fn _serialize_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;
        use ::futures::StreamExt as _;
        use ::fbthrift::Deserialize as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"Factories";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Factories.serialize";
        const INTERACTION_NAME: &::std::ffi::CStr = c"SerialInteraction";
        let args = self::Args_Factories_serialize {
            _phantom: ::std::marker::PhantomData,
        };

        let interaction_transport = match self.transport().create_interaction(INTERACTION_NAME) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };
        let interaction_impl = crate::factories::SerialInteractionImpl::<P, T, S>::new(interaction_transport);
        let transport = interaction_impl.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("serialize", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call_stream = transport
            .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call_stream", method = "Factories.serialize"));

        async move {
            let (initial, stream) = call_stream.await?;

            let new_stream = stream.then(|item_res| {
                async move {
                    match item_res {
                        ::std::result::Result::Err(err) =>
                            ::std::result::Result::Err(crate::errors::factories::SerializeStreamError::from(err)),
                        ::std::result::Result::Ok(item_enc) => {
                            S::spawn(move || {
                                match item_enc {
                                    ::fbthrift::ClientStreamElement::Reply(payload) => {
                                        let mut de = P::deserializer(payload);
                                        <crate::errors::factories::SerializeStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                    }
                                    ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                        let mut de = P::deserializer(payload);
                                        let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                        ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::factories::SerializeStreamError::ApplicationException(aexn)))
                                    }
                                }
                            }).await.map_err(::anyhow::Error::from)??
                        }
                    }
                }
            })
            .boxed();

            let de = P::deserializer(initial);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::factories::SerializeReader, S>(de)
                .await??
                .map(move |initial| (initial, new_stream));
            let interaction_client: crate::client::factories::SerialInteractionClient = ::std::sync::Arc::new(interaction_impl);
            ::std::result::Result::Ok((interaction_client, res?))
        }
        .instrument(::tracing::info_span!("stream", method = "Factories.serialize"))
        .boxed()
    }
}

impl<P, T, S> ::fbthrift::help::GetTransport<T> for FactoriesImpl<P, T, S>
where
    T: ::fbthrift::Transport,
{
    fn transport(&self) -> &T {
        &self.transport
    }
}



struct Args_Factories_foo<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_Factories_foo<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "Factories.foo"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

struct Args_Factories_interact<'a> {
    arg: ::std::primitive::i32,
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_Factories_interact<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "Factories.interact"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_begin("arg", ::fbthrift::TType::I32, 1i16);
        ::fbthrift::Serialize::write(&self.arg, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

struct Args_Factories_interactFast<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_Factories_interactFast<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "Factories.interactFast"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

struct Args_Factories_serialize<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_Factories_serialize<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "Factories.serialize"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P, T, S> Factories for FactoriesImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>> {
        let rpc_options = T::RpcOptions::default();
        self._foo_impl(
            rpc_options,
        )
    }
    fn interact(
        &self,
        arg_arg: ::std::primitive::i32,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>> {
        let rpc_options = T::RpcOptions::default();
        self._interact_impl(
            arg_arg,
            rpc_options,
        )
    }
    fn interactFast(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>> {
        let rpc_options = T::RpcOptions::default();
        self._interactFast_impl(
            rpc_options,
        )
    }
    fn serialize(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>> {
        let rpc_options = T::RpcOptions::default();
        self._serialize_impl(
            rpc_options,
        )
    }
}

impl<P, T, S> FactoriesExt<T> for FactoriesImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::factories::FooError>> {
        self._foo_impl(
            rpc_options,
        )
    }
    fn interact_with_rpc_opts(
        &self,
        arg_arg: ::std::primitive::i32,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::client::factories::MyInteractionClient, crate::errors::factories::InteractError>> {
        self._interact_impl(
            arg_arg,
            rpc_options,
        )
    }
    fn interactFast_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::MyInteractionFastClient, ::std::primitive::i32), crate::errors::factories::InteractFastError>> {
        self._interactFast_impl(
            rpc_options,
        )
    }
    fn serialize_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(crate::client::factories::SerialInteractionClient, (::std::primitive::i32, ::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::i32, crate::errors::factories::SerializeStreamError>>)), crate::errors::factories::SerializeError>> {
        self._serialize_impl(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        self.transport()
    }
}

#[derive(Clone)]
pub struct make_Factories;

/// To be called by user directly setting up a client. Avoids
/// needing ClientFactory trait in scope, avoids unidiomatic
/// make_Trait name.
///
/// ```
/// # const _: &str = stringify! {
/// use bgs::client::BuckGraphService;
///
/// let protocol = BinaryProtocol::new();
/// let transport = HttpClient::new();
/// let client = <dyn BuckGraphService>::new(protocol, transport);
/// # };
/// ```
impl dyn Factories {
    pub fn new<P, T>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl Factories + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, T, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl Factories + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(FactoriesImpl::<P, T, S>::new(transport))
    }
}

impl<T> dyn FactoriesExt<T>
where
    T: ::fbthrift::Transport,
{
    pub fn new<P>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl FactoriesExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl FactoriesExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(FactoriesImpl::<P, T, S>::new(transport))
    }
}

pub type FactoriesDynClient = <make_Factories as ::fbthrift::ClientFactory>::Api;
pub type FactoriesClient = ::std::sync::Arc<FactoriesDynClient>;

/// The same thing, but to be called from generic contexts where we are
/// working with a type parameter `C: ClientFactory` to produce clients.
impl ::fbthrift::ClientFactory for make_Factories {
    type Api = dyn Factories + ::std::marker::Send + ::std::marker::Sync + 'static;

    fn with_spawner<P, T, S>(protocol: P, transport: T, spawner: S) -> ::std::sync::Arc<Self::Api>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        <dyn Factories>::with_spawner(protocol, transport, spawner)
    }
}


pub mod perform {
    use super::*;
    
    
    /// Client definitions for `MyInteraction`.
    pub struct MyInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.MyInteraction.frobnicate";
            let args = self::Args_MyInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.MyInteraction.ping";
            let args = self::Args_MyInteraction_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.MyInteraction.truthify";
            let args = self::Args_MyInteraction_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteraction.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteraction for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionExt<T> for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionDynClient = dyn MyInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionClient = ::std::sync::Arc<MyInteractionDynClient>;
    
    
        
    
    /// Client definitions for `MyInteractionFast`.
    pub struct MyInteractionFastImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.MyInteractionFast.frobnicate";
            let args = self::Args_MyInteractionFast_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteractionFast.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction_fast::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.MyInteractionFast.ping";
            let args = self::Args_MyInteractionFast_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteractionFast.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction_fast::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.MyInteractionFast.truthify";
            let args = self::Args_MyInteractionFast_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteractionFast.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteractionFast.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction_fast::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction_fast::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction_fast::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction_fast::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteractionFast.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionFastImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteractionFast_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteractionFast_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteractionFast_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteractionFast_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteractionFast.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteractionFast for MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionFastExt<T> for MyInteractionFastImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction_fast::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction_fast::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction_fast::TruthifyStreamError>>, crate::errors::my_interaction_fast::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionFastDynClient = dyn MyInteractionFast + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionFastClient = ::std::sync::Arc<MyInteractionFastDynClient>;
    
    
        
    
    /// Client definitions for `SerialInteraction`.
    pub struct SerialInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.SerialInteraction.frobnicate";
            let args = self::Args_SerialInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("SerialInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "SerialInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::serial_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::serial_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "SerialInteraction.frobnicate"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for SerialInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_SerialInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_SerialInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "SerialInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> SerialInteraction for SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> SerialInteractionExt<T> for SerialInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::serial_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type SerialInteractionDynClient = dyn SerialInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type SerialInteractionClient = ::std::sync::Arc<SerialInteractionDynClient>;
    
    
    
}

pub trait Perform: ::std::marker::Send {
    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::perform::MyInteractionClient, ::anyhow::Error>;

    fn createMyInteractionFast(
        &self,
    ) -> ::std::result::Result<crate::client::perform::MyInteractionFastClient, ::anyhow::Error>;

    fn createSerialInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::perform::SerialInteractionClient, ::anyhow::Error>;

    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>>;
}

pub trait PerformExt<T>: Perform
where
    T: ::fbthrift::Transport,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> Perform for S
where
    S: ::std::convert::AsRef<dyn Perform + 'a>,
    S: ::std::marker::Send,
{
    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::perform::MyInteractionClient, ::anyhow::Error> {
        self.as_ref().createMyInteraction()
    }
    fn createMyInteractionFast(
        &self,
    ) -> ::std::result::Result<crate::client::perform::MyInteractionFastClient, ::anyhow::Error> {
        self.as_ref().createMyInteractionFast()
    }
    fn createSerialInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::perform::SerialInteractionClient, ::anyhow::Error> {
        self.as_ref().createSerialInteraction()
    }
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>> {
        self.as_ref().foo(
        )
    }
}

#[allow(deprecated)]
impl<'a, S, T> PerformExt<T> for S
where
    S: ::std::convert::AsRef<dyn Perform + 'a> + ::std::convert::AsRef<dyn PerformExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>> {
        <Self as ::std::convert::AsRef<dyn PerformExt<T>>>::as_ref(self).foo_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}
/// Client definitions for `Perform`.
pub struct PerformImpl<P, T, S = ::fbthrift::NoopSpawner> {
    transport: T,
    _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
}

impl<P, T, S> PerformImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    pub fn new(
        transport: T,
    ) -> Self {
        Self {
            transport,
            _phantom: ::std::marker::PhantomData,
        }
    }

    pub fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }


    fn _foo_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"Perform";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"Perform.foo";
        let args = self::Args_Perform_foo {
            _phantom: ::std::marker::PhantomData,
        };

        let transport = self.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("foo", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "Perform.foo"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::perform::FooReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::perform::FooError::ApplicationException(aexn))
                }
            };
            res
        }
        .instrument(::tracing::info_span!("stream", method = "Perform.foo"))
        .boxed()
    }
}

impl<P, T, S> ::fbthrift::help::GetTransport<T> for PerformImpl<P, T, S>
where
    T: ::fbthrift::Transport,
{
    fn transport(&self) -> &T {
        &self.transport
    }
}



struct Args_Perform_foo<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_Perform_foo<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "Perform.foo"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P, T, S> Perform for PerformImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{

    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::perform::MyInteractionClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::perform::MyInteractionImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"MyInteraction")?
                )
            )
        )
    }

    fn createMyInteractionFast(
        &self,
    ) -> ::std::result::Result<crate::client::perform::MyInteractionFastClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::perform::MyInteractionFastImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"MyInteractionFast")?
                )
            )
        )
    }

    fn createSerialInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::perform::SerialInteractionClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::perform::SerialInteractionImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"SerialInteraction")?
                )
            )
        )
    }
    fn foo(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>> {
        let rpc_options = T::RpcOptions::default();
        self._foo_impl(
            rpc_options,
        )
    }
}

impl<P, T, S> PerformExt<T> for PerformImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    fn foo_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::perform::FooError>> {
        self._foo_impl(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        self.transport()
    }
}

#[derive(Clone)]
pub struct make_Perform;

/// To be called by user directly setting up a client. Avoids
/// needing ClientFactory trait in scope, avoids unidiomatic
/// make_Trait name.
///
/// ```
/// # const _: &str = stringify! {
/// use bgs::client::BuckGraphService;
///
/// let protocol = BinaryProtocol::new();
/// let transport = HttpClient::new();
/// let client = <dyn BuckGraphService>::new(protocol, transport);
/// # };
/// ```
impl dyn Perform {
    pub fn new<P, T>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl Perform + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, T, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl Perform + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(PerformImpl::<P, T, S>::new(transport))
    }
}

impl<T> dyn PerformExt<T>
where
    T: ::fbthrift::Transport,
{
    pub fn new<P>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl PerformExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl PerformExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(PerformImpl::<P, T, S>::new(transport))
    }
}

pub type PerformDynClient = <make_Perform as ::fbthrift::ClientFactory>::Api;
pub type PerformClient = ::std::sync::Arc<PerformDynClient>;

/// The same thing, but to be called from generic contexts where we are
/// working with a type parameter `C: ClientFactory` to produce clients.
impl ::fbthrift::ClientFactory for make_Perform {
    type Api = dyn Perform + ::std::marker::Send + ::std::marker::Sync + 'static;

    fn with_spawner<P, T, S>(protocol: P, transport: T, spawner: S) -> ::std::sync::Arc<Self::Api>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        <dyn Perform>::with_spawner(protocol, transport, spawner)
    }
}


pub mod interact_with_shared {
    use super::*;
    
    
    /// Client definitions for `MyInteraction`.
    pub struct MyInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _frobnicate_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.MyInteraction.frobnicate";
            let args = self::Args_MyInteraction_frobnicate {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.frobnicate", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.frobnicate"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::FrobnicateReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::FrobnicateError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.frobnicate"))
            .boxed()
        }
    
        fn _ping_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.MyInteraction.ping";
            let args = self::Args_MyInteraction_ping {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.ping", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "MyInteraction.ping"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::PingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::my_interaction::PingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.ping"))
            .boxed()
        }
    
        fn _truthify_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
            use ::futures::StreamExt as _;
            use ::fbthrift::Deserialize as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.MyInteraction.truthify";
            let args = self::Args_MyInteraction_truthify {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("MyInteraction.truthify", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call_stream = transport
                .call_stream(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call_stream", method = "MyInteraction.truthify"));
    
            async move {
                let (initial, stream) = call_stream.await?;
    
                let new_stream = stream.then(|item_res| {
                    async move {
                        match item_res {
                            ::std::result::Result::Err(err) =>
                                ::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::from(err)),
                            ::std::result::Result::Ok(item_enc) => {
                                S::spawn(move || {
                                    match item_enc {
                                        ::fbthrift::ClientStreamElement::Reply(payload) => {
                                            let mut de = P::deserializer(payload);
                                            <crate::errors::my_interaction::TruthifyStreamReader as ::fbthrift::help::DeserializeExn>::read_result(&mut de)
                                        }
                                        ::fbthrift::ClientStreamElement::ApplicationEx(payload) => {
                                            let mut de = P::deserializer(payload);
                                            let aexn = ::fbthrift::ApplicationException::read(&mut de)?;
                                            ::std::result::Result::Ok(::std::result::Result::Err(crate::errors::my_interaction::TruthifyStreamError::ApplicationException(aexn)))
                                        }
                                    }
                                }).await.map_err(::anyhow::Error::from)??
                            }
                        }
                    }
                })
                .boxed();
    
                let de = P::deserializer(initial);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::my_interaction::TruthifyReader, S>(de)
                    .await??
                    .map(move |_| new_stream);
                res
            }
            .instrument(::tracing::info_span!("stream", method = "MyInteraction.truthify"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for MyInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_MyInteraction_frobnicate<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_frobnicate<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.frobnicate"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_ping<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_ping<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.ping"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_MyInteraction_truthify<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MyInteraction_truthify<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MyInteraction.truthify"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> MyInteraction for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            let rpc_options = T::RpcOptions::default();
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            let rpc_options = T::RpcOptions::default();
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            let rpc_options = T::RpcOptions::default();
            self._truthify_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> MyInteractionExt<T> for MyInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn frobnicate_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::my_interaction::FrobnicateError>> {
            self._frobnicate_impl(
                rpc_options,
            )
        }
        fn ping_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::my_interaction::PingError>> {
            self._ping_impl(
                rpc_options,
            )
        }
        fn truthify_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::futures::stream::BoxStream<'static, ::std::result::Result<::std::primitive::bool, crate::errors::my_interaction::TruthifyStreamError>>, crate::errors::my_interaction::TruthifyError>> {
            self._truthify_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type MyInteractionDynClient = dyn MyInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type MyInteractionClient = ::std::sync::Arc<MyInteractionDynClient>;
    
    
        
    
    /// Client definitions for `SharedInteraction`.
    pub struct SharedInteractionImpl<P, T, S = ::fbthrift::NoopSpawner> {
        transport: T,
        _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
    }
    
    impl<P, T, S> SharedInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        pub fn new(
            transport: T,
        ) -> Self {
            Self {
                transport,
                _phantom: ::std::marker::PhantomData,
            }
        }
    
        pub fn transport(&self) -> &T {
            ::fbthrift::help::GetTransport::transport(self)
        }
    
    
        fn _init_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::shared_interaction::InitError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.SharedInteraction.init";
            let args = self::Args_SharedInteraction_init {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("SharedInteraction.init", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "SharedInteraction.init"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::shared_interaction::InitReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::shared_interaction::InitError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "SharedInteraction.init"))
            .boxed()
        }
    
        fn _do_something_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::shared_interaction::DoSomethingError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.SharedInteraction.do_something";
            let args = self::Args_SharedInteraction_do_something {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("SharedInteraction.do_something", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "SharedInteraction.do_something"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::shared_interaction::DoSomethingReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::shared_interaction::DoSomethingError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "SharedInteraction.do_something"))
            .boxed()
        }
    
        fn _tear_down_impl(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::shared_interaction::TearDownError>> {
            use ::tracing::Instrument as _;
            use ::futures::FutureExt as _;
    
            const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
            const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.SharedInteraction.tear_down";
            let args = self::Args_SharedInteraction_tear_down {
                _phantom: ::std::marker::PhantomData,
            };
    
            let transport = self.transport();
    
            // need to do call setup outside of async block because T: Transport isn't Send
            let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("SharedInteraction.tear_down", &args) {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
            };
    
            let call = transport
                .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
                .instrument(::tracing::trace_span!("call", method = "SharedInteraction.tear_down"));
    
            async move {
                let reply_env = call.await?;
    
                let de = P::deserializer(reply_env);
                let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::shared_interaction::TearDownReader, S>(de).await?;
    
                let res = match res {
                    ::std::result::Result::Ok(res) => res,
                    ::std::result::Result::Err(aexn) => {
                        ::std::result::Result::Err(crate::errors::shared_interaction::TearDownError::ApplicationException(aexn))
                    }
                };
                res
            }
            .instrument(::tracing::info_span!("stream", method = "SharedInteraction.tear_down"))
            .boxed()
        }
    }
    
    impl<P, T, S> ::fbthrift::help::GetTransport<T> for SharedInteractionImpl<P, T, S>
    where
        T: ::fbthrift::Transport,
    {
        fn transport(&self) -> &T {
            &self.transport
        }
    }
    
    
    
    struct Args_SharedInteraction_init<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_SharedInteraction_init<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "SharedInteraction.init"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_SharedInteraction_do_something<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_SharedInteraction_do_something<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "SharedInteraction.do_something"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    struct Args_SharedInteraction_tear_down<'a> {
        _phantom: ::std::marker::PhantomData<&'a ()>,
    }
    
    impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_SharedInteraction_tear_down<'a> {
        #[inline]
        #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "SharedInteraction.tear_down"))]
        fn write(&self, p: &mut P) {
            p.write_struct_begin("args");
            p.write_field_stop();
            p.write_struct_end();
        }
    }
    
    impl<P, T, S> SharedInteraction for SharedInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn init(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::shared_interaction::InitError>> {
            let rpc_options = T::RpcOptions::default();
            self._init_impl(
                rpc_options,
            )
        }
        fn do_something(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::shared_interaction::DoSomethingError>> {
            let rpc_options = T::RpcOptions::default();
            self._do_something_impl(
                rpc_options,
            )
        }
        fn tear_down(
            &self,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::shared_interaction::TearDownError>> {
            let rpc_options = T::RpcOptions::default();
            self._tear_down_impl(
                rpc_options,
            )
        }
    }
    
    impl<P, T, S> SharedInteractionExt<T> for SharedInteractionImpl<P, T, S>
    where
        P: ::fbthrift::Protocol,
        T: ::fbthrift::Transport,
        P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
        ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        fn init_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<::std::primitive::i32, crate::errors::shared_interaction::InitError>> {
            self._init_impl(
                rpc_options,
            )
        }
        fn do_something_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::shared_interaction::DoSomethingError>> {
            self._do_something_impl(
                rpc_options,
            )
        }
        fn tear_down_with_rpc_opts(
            &self,
            rpc_options: T::RpcOptions,
        ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<(), crate::errors::shared_interaction::TearDownError>> {
            self._tear_down_impl(
                rpc_options,
            )
        }
    
        fn transport(&self) -> &T {
            self.transport()
        }
    }
    
    pub type SharedInteractionDynClient = dyn SharedInteraction + ::std::marker::Send + ::std::marker::Sync + 'static;
    pub type SharedInteractionClient = ::std::sync::Arc<SharedInteractionDynClient>;
    
    
    
}

pub trait InteractWithShared: ::std::marker::Send {
    fn do_some_similar_things(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>>;

    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::interact_with_shared::MyInteractionClient, ::anyhow::Error>;

    fn createshared.SharedInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::interact_with_shared::SharedInteractionClient, ::anyhow::Error>;
}

pub trait InteractWithSharedExt<T>: InteractWithShared
where
    T: ::fbthrift::Transport,
{
    fn do_some_similar_things_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>>;

    fn transport(&self) -> &T;
}

#[allow(deprecated)]
impl<'a, S> InteractWithShared for S
where
    S: ::std::convert::AsRef<dyn InteractWithShared + 'a>,
    S: ::std::marker::Send,
{
    fn do_some_similar_things(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>> {
        self.as_ref().do_some_similar_things(
        )
    }
    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::interact_with_shared::MyInteractionClient, ::anyhow::Error> {
        self.as_ref().createMyInteraction()
    }
    fn createshared.SharedInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::interact_with_shared::SharedInteractionClient, ::anyhow::Error> {
        self.as_ref().createshared.SharedInteraction()
    }
}

#[allow(deprecated)]
impl<'a, S, T> InteractWithSharedExt<T> for S
where
    S: ::std::convert::AsRef<dyn InteractWithShared + 'a> + ::std::convert::AsRef<dyn InteractWithSharedExt<T> + 'a>,
    S: ::std::marker::Send + ::fbthrift::help::GetTransport<T>,
    T: ::fbthrift::Transport,
{
    fn do_some_similar_things_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>> {
        <Self as ::std::convert::AsRef<dyn InteractWithSharedExt<T>>>::as_ref(self).do_some_similar_things_with_rpc_opts(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }
}
/// Client definitions for `InteractWithShared`.
pub struct InteractWithSharedImpl<P, T, S = ::fbthrift::NoopSpawner> {
    transport: T,
    _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
}

impl<P, T, S> InteractWithSharedImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    pub fn new(
        transport: T,
    ) -> Self {
        Self {
            transport,
            _phantom: ::std::marker::PhantomData,
        }
    }

    pub fn transport(&self) -> &T {
        ::fbthrift::help::GetTransport::transport(self)
    }


    fn _do_some_similar_things_impl(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>> {
        use ::tracing::Instrument as _;
        use ::futures::FutureExt as _;

        const SERVICE_NAME: &::std::ffi::CStr = c"InteractWithShared";
        const SERVICE_METHOD_NAME: &::std::ffi::CStr = c"InteractWithShared.do_some_similar_things";
        let args = self::Args_InteractWithShared_do_some_similar_things {
            _phantom: ::std::marker::PhantomData,
        };

        let transport = self.transport();

        // need to do call setup outside of async block because T: Transport isn't Send
        let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("do_some_similar_things", &args) {
            ::std::result::Result::Ok(res) => res,
            ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
        };

        let call = transport
            .call(SERVICE_NAME, SERVICE_METHOD_NAME, request_env, rpc_options)
            .instrument(::tracing::trace_span!("call", method = "InteractWithShared.do_some_similar_things"));

        async move {
            let reply_env = call.await?;

            let de = P::deserializer(reply_env);
            let res = ::fbthrift::help::async_deserialize_response_envelope::<P, crate::errors::interact_with_shared::DoSomeSimilarThingsReader, S>(de).await?;

            let res = match res {
                ::std::result::Result::Ok(res) => res,
                ::std::result::Result::Err(aexn) => {
                    ::std::result::Result::Err(crate::errors::interact_with_shared::DoSomeSimilarThingsError::ApplicationException(aexn))
                }
            };
            res
        }
        .instrument(::tracing::info_span!("stream", method = "InteractWithShared.do_some_similar_things"))
        .boxed()
    }
}

impl<P, T, S> ::fbthrift::help::GetTransport<T> for InteractWithSharedImpl<P, T, S>
where
    T: ::fbthrift::Transport,
{
    fn transport(&self) -> &T {
        &self.transport
    }
}



struct Args_InteractWithShared_do_some_similar_things<'a> {
    _phantom: ::std::marker::PhantomData<&'a ()>,
}

impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_InteractWithShared_do_some_similar_things<'a> {
    #[inline]
    #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "InteractWithShared.do_some_similar_things"))]
    fn write(&self, p: &mut P) {
        p.write_struct_begin("args");
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P, T, S> InteractWithShared for InteractWithSharedImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    fn do_some_similar_things(
        &self,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>> {
        let rpc_options = T::RpcOptions::default();
        self._do_some_similar_things_impl(
            rpc_options,
        )
    }

    fn createMyInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::interact_with_shared::MyInteractionClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::interact_with_shared::MyInteractionImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"MyInteraction")?
                )
            )
        )
    }

    fn createshared.SharedInteraction(
        &self,
    ) -> ::std::result::Result<crate::client::interact_with_shared::SharedInteractionClient, ::anyhow::Error> {
        ::std::result::Result::Ok(
            ::std::sync::Arc::new(
                crate::client::interact_with_shared::SharedInteractionImpl::<P, T, S>::new(
                    self.transport().create_interaction(c"SharedInteraction")?
                )
            )
        )
    }
}

impl<P, T, S> InteractWithSharedExt<T> for InteractWithSharedImpl<P, T, S>
where
    P: ::fbthrift::Protocol,
    T: ::fbthrift::Transport,
    P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
    ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
    P::Deserializer: ::std::marker::Send,
    S: ::fbthrift::help::Spawner,
{
    fn do_some_similar_things_with_rpc_opts(
        &self,
        rpc_options: T::RpcOptions,
    ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<shared__types::DoSomethingResult, crate::errors::interact_with_shared::DoSomeSimilarThingsError>> {
        self._do_some_similar_things_impl(
            rpc_options,
        )
    }

    fn transport(&self) -> &T {
        self.transport()
    }
}

#[derive(Clone)]
pub struct make_InteractWithShared;

/// To be called by user directly setting up a client. Avoids
/// needing ClientFactory trait in scope, avoids unidiomatic
/// make_Trait name.
///
/// ```
/// # const _: &str = stringify! {
/// use bgs::client::BuckGraphService;
///
/// let protocol = BinaryProtocol::new();
/// let transport = HttpClient::new();
/// let client = <dyn BuckGraphService>::new(protocol, transport);
/// # };
/// ```
impl dyn InteractWithShared {
    pub fn new<P, T>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl InteractWithShared + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, T, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl InteractWithShared + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(InteractWithSharedImpl::<P, T, S>::new(transport))
    }
}

impl<T> dyn InteractWithSharedExt<T>
where
    T: ::fbthrift::Transport,
{
    pub fn new<P>(
        protocol: P,
        transport: T,
    ) -> ::std::sync::Arc<impl InteractWithSharedExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
    {
        let spawner = ::fbthrift::help::NoopSpawner;
        Self::with_spawner(protocol, transport, spawner)
    }

    pub fn with_spawner<P, S>(
        protocol: P,
        transport: T,
        spawner: S,
    ) -> ::std::sync::Arc<impl InteractWithSharedExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        let _ = protocol;
        let _ = spawner;
        ::std::sync::Arc::new(InteractWithSharedImpl::<P, T, S>::new(transport))
    }
}

pub type InteractWithSharedDynClient = <make_InteractWithShared as ::fbthrift::ClientFactory>::Api;
pub type InteractWithSharedClient = ::std::sync::Arc<InteractWithSharedDynClient>;

/// The same thing, but to be called from generic contexts where we are
/// working with a type parameter `C: ClientFactory` to produce clients.
impl ::fbthrift::ClientFactory for make_InteractWithShared {
    type Api = dyn InteractWithShared + ::std::marker::Send + ::std::marker::Sync + 'static;

    fn with_spawner<P, T, S>(protocol: P, transport: T, spawner: S) -> ::std::sync::Arc<Self::Api>
    where
        P: ::fbthrift::Protocol<Frame = T>,
        T: ::fbthrift::Transport,
        P::Deserializer: ::std::marker::Send,
        S: ::fbthrift::help::Spawner,
    {
        <dyn InteractWithShared>::with_spawner(protocol, transport, spawner)
    }
}