fidl_fuchsia_bluetooth_hfp/

fidl_fuchsia_bluetooth_hfp.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_bluetooth_hfp__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, PartialEq)]
pub struct CallManagerPeerConnectedRequest {
    pub id: fidl_fuchsia_bluetooth::PeerId,
    pub handle: fidl::endpoints::ServerEnd<PeerHandlerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for CallManagerPeerConnectedRequest
{
}

#[derive(Debug, PartialEq)]
pub struct HandsFreeWatchPeerConnectedResponse {
    pub id: fidl_fuchsia_bluetooth::PeerId,
    pub handle: fidl::endpoints::ClientEnd<PeerHandlerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for HandsFreeWatchPeerConnectedResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct HfpRegisterRequest {
    pub manager: fidl::endpoints::ClientEnd<CallManagerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for HfpRegisterRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PeerHandlerGainControlRequest {
    pub control: fidl::endpoints::ClientEnd<HeadsetGainMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for PeerHandlerGainControlRequest
{
}

#[derive(Debug, PartialEq)]
pub struct PeerHandlerWatchNextCallResponse {
    pub call: NextCall,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for PeerHandlerWatchNextCallResponse
{
}

/// Information for the next call reported by a Peer Handler.
#[derive(Debug, Default, PartialEq)]
pub struct NextCall {
    /// Channel for this call.
    /// This field is required.
    pub call: Option<fidl::endpoints::ClientEnd<CallMarker>>,
    /// The Number of the remote party on the call.
    /// This field is required.
    pub remote: Option<String>,
    /// State of the call when it is reported by the Peer Handler.
    /// This field is required.
    pub state: Option<CallState>,
    /// Direction of the call's initiation. See `CallDirection` documentation
    /// for more information.
    /// This field is required.
    pub direction: Option<CallDirection>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for NextCall {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CallMarker;

impl fidl::endpoints::ProtocolMarker for CallMarker {
    type Proxy = CallProxy;
    type RequestStream = CallRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CallSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Call";
}
pub type CallSendDtmfCodeResult = Result<(), i32>;

pub trait CallProxyInterface: Send + Sync {
    type WatchStateResponseFut: std::future::Future<Output = Result<CallState, fidl::Error>> + Send;
    fn r#watch_state(&self) -> Self::WatchStateResponseFut;
    fn r#request_hold(&self) -> Result<(), fidl::Error>;
    fn r#request_active(&self) -> Result<(), fidl::Error>;
    fn r#request_terminate(&self) -> Result<(), fidl::Error>;
    fn r#request_transfer_audio(&self) -> Result<(), fidl::Error>;
    type SendDtmfCodeResponseFut: std::future::Future<Output = Result<CallSendDtmfCodeResult, fidl::Error>>
        + Send;
    fn r#send_dtmf_code(&self, code: DtmfCode) -> Self::SendDtmfCodeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CallSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CallSynchronousProxy {
    type Proxy = CallProxy;
    type Protocol = CallMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl CallSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<CallEvent, fidl::Error> {
        CallEvent::decode(self.client.wait_for_event::<CallMarker>(deadline)?)
    }

    /// A hanging get method for call state. See the `CallState` documentation
    /// for information on possible states.
    pub fn r#watch_state(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CallState, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, CallWatchStateResponse, CallMarker>(
                (),
                0x5262bcc909bdaeb5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// Request that the Call be set to the ONGOING_HELD CallState
    pub fn r#request_hold(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x35ade403017d20eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Request that the Call be set to the ONGOING_ACTIVE CallState.
    /// This has the side effect of placing all other Calls that are routed to
    /// this peer in the ONGOING_HELD call state if it succeeds.
    pub fn r#request_active(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x248518f967f1fe6e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Request that the Call be TERMINATED.
    pub fn r#request_terminate(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x4940915197ee4916,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Request that the Call's audio be transfered to the Audio Gateway and
    /// the call state set to TRANSFERRED_TO_AG.
    pub fn r#request_transfer_audio(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xb0ca6649f2e104c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Send a code that the call manager or remote audio gateway peer should
    /// transmit to its network connection. The request returns after the code
    /// has been transmitted to the network.
    ///
    /// Can return an error if the call manager or peer failed to transmit the
    /// code to the network.
    pub fn r#send_dtmf_code(
        &self,
        mut code: DtmfCode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CallSendDtmfCodeResult, fidl::Error> {
        let _response = self.client.send_query::<
            CallSendDtmfCodeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            CallMarker,
        >(
            (code,),
            0x50768933ca33fcd6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<CallSynchronousProxy> for zx::NullableHandle {
    fn from(value: CallSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for CallSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for CallSynchronousProxy {
    type Protocol = CallMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<CallMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct CallProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for CallProxy {
    type Protocol = CallMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl CallProxy {
    /// Create a new Proxy for fuchsia.bluetooth.hfp/Call.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CallMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CallEventStream {
        CallEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// A hanging get method for call state. See the `CallState` documentation
    /// for information on possible states.
    pub fn r#watch_state(
        &self,
    ) -> fidl::client::QueryResponseFut<CallState, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        CallProxyInterface::r#watch_state(self)
    }

    /// Request that the Call be set to the ONGOING_HELD CallState
    pub fn r#request_hold(&self) -> Result<(), fidl::Error> {
        CallProxyInterface::r#request_hold(self)
    }

    /// Request that the Call be set to the ONGOING_ACTIVE CallState.
    /// This has the side effect of placing all other Calls that are routed to
    /// this peer in the ONGOING_HELD call state if it succeeds.
    pub fn r#request_active(&self) -> Result<(), fidl::Error> {
        CallProxyInterface::r#request_active(self)
    }

    /// Request that the Call be TERMINATED.
    pub fn r#request_terminate(&self) -> Result<(), fidl::Error> {
        CallProxyInterface::r#request_terminate(self)
    }

    /// Request that the Call's audio be transfered to the Audio Gateway and
    /// the call state set to TRANSFERRED_TO_AG.
    pub fn r#request_transfer_audio(&self) -> Result<(), fidl::Error> {
        CallProxyInterface::r#request_transfer_audio(self)
    }

    /// Send a code that the call manager or remote audio gateway peer should
    /// transmit to its network connection. The request returns after the code
    /// has been transmitted to the network.
    ///
    /// Can return an error if the call manager or peer failed to transmit the
    /// code to the network.
    pub fn r#send_dtmf_code(
        &self,
        mut code: DtmfCode,
    ) -> fidl::client::QueryResponseFut<
        CallSendDtmfCodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CallProxyInterface::r#send_dtmf_code(self, code)
    }
}

impl CallProxyInterface for CallProxy {
    type WatchStateResponseFut =
        fidl::client::QueryResponseFut<CallState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_state(&self) -> Self::WatchStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CallState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CallWatchStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5262bcc909bdaeb5,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, CallState>(
            (),
            0x5262bcc909bdaeb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#request_hold(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x35ade403017d20eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#request_active(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x248518f967f1fe6e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#request_terminate(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x4940915197ee4916,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#request_transfer_audio(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xb0ca6649f2e104c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SendDtmfCodeResponseFut = fidl::client::QueryResponseFut<
        CallSendDtmfCodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#send_dtmf_code(&self, mut code: DtmfCode) -> Self::SendDtmfCodeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CallSendDtmfCodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x50768933ca33fcd6,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<CallSendDtmfCodeRequest, CallSendDtmfCodeResult>(
            (code,),
            0x50768933ca33fcd6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct CallEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for CallEventStream {}

impl futures::stream::FusedStream for CallEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for CallEventStream {
    type Item = Result<CallEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(CallEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum CallEvent {}

impl CallEvent {
    /// Decodes a message buffer as a [`CallEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<CallEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <CallMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.hfp/Call.
pub struct CallRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for CallRequestStream {}

impl futures::stream::FusedStream for CallRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for CallRequestStream {
    type Protocol = CallMarker;
    type ControlHandle = CallControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        CallControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for CallRequestStream {
    type Item = Result<CallRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled CallRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5262bcc909bdaeb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallControlHandle { inner: this.inner.clone() };
                        Ok(CallRequest::WatchState {
                            responder: CallWatchStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35ade403017d20eb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallControlHandle { inner: this.inner.clone() };
                        Ok(CallRequest::RequestHold { control_handle })
                    }
                    0x248518f967f1fe6e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallControlHandle { inner: this.inner.clone() };
                        Ok(CallRequest::RequestActive { control_handle })
                    }
                    0x4940915197ee4916 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallControlHandle { inner: this.inner.clone() };
                        Ok(CallRequest::RequestTerminate { control_handle })
                    }
                    0xb0ca6649f2e104c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallControlHandle { inner: this.inner.clone() };
                        Ok(CallRequest::RequestTransferAudio { control_handle })
                    }
                    0x50768933ca33fcd6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CallSendDtmfCodeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CallSendDtmfCodeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallControlHandle { inner: this.inner.clone() };
                        Ok(CallRequest::SendDtmfCode {
                            code: req.code,

                            responder: CallSendDtmfCodeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <CallMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Controls the lifecycle of a call that has been routed through a headset. A
/// client that wishes to know when a call is terminated should keep this
/// protocol open until it has received a Terminated state update from the
/// WatchState call.  However, closing the protocol will also hang up the call
/// safely.
#[derive(Debug)]
pub enum CallRequest {
    /// A hanging get method for call state. See the `CallState` documentation
    /// for information on possible states.
    WatchState { responder: CallWatchStateResponder },
    /// Request that the Call be set to the ONGOING_HELD CallState
    RequestHold { control_handle: CallControlHandle },
    /// Request that the Call be set to the ONGOING_ACTIVE CallState.
    /// This has the side effect of placing all other Calls that are routed to
    /// this peer in the ONGOING_HELD call state if it succeeds.
    RequestActive { control_handle: CallControlHandle },
    /// Request that the Call be TERMINATED.
    RequestTerminate { control_handle: CallControlHandle },
    /// Request that the Call's audio be transfered to the Audio Gateway and
    /// the call state set to TRANSFERRED_TO_AG.
    RequestTransferAudio { control_handle: CallControlHandle },
    /// Send a code that the call manager or remote audio gateway peer should
    /// transmit to its network connection. The request returns after the code
    /// has been transmitted to the network.
    ///
    /// Can return an error if the call manager or peer failed to transmit the
    /// code to the network.
    SendDtmfCode { code: DtmfCode, responder: CallSendDtmfCodeResponder },
}

impl CallRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_state(self) -> Option<(CallWatchStateResponder)> {
        if let CallRequest::WatchState { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_hold(self) -> Option<(CallControlHandle)> {
        if let CallRequest::RequestHold { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_active(self) -> Option<(CallControlHandle)> {
        if let CallRequest::RequestActive { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_terminate(self) -> Option<(CallControlHandle)> {
        if let CallRequest::RequestTerminate { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_transfer_audio(self) -> Option<(CallControlHandle)> {
        if let CallRequest::RequestTransferAudio { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_dtmf_code(self) -> Option<(DtmfCode, CallSendDtmfCodeResponder)> {
        if let CallRequest::SendDtmfCode { code, responder } = self {
            Some((code, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CallRequest::WatchState { .. } => "watch_state",
            CallRequest::RequestHold { .. } => "request_hold",
            CallRequest::RequestActive { .. } => "request_active",
            CallRequest::RequestTerminate { .. } => "request_terminate",
            CallRequest::RequestTransferAudio { .. } => "request_transfer_audio",
            CallRequest::SendDtmfCode { .. } => "send_dtmf_code",
        }
    }
}

#[derive(Debug, Clone)]
pub struct CallControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for CallControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl CallControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CallWatchStateResponder {
    control_handle: std::mem::ManuallyDrop<CallControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`CallControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for CallWatchStateResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CallWatchStateResponder {
    type ControlHandle = CallControlHandle;

    fn control_handle(&self) -> &CallControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl CallWatchStateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut state: CallState) -> Result<(), fidl::Error> {
        let _result = self.send_raw(state);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut state: CallState) -> Result<(), fidl::Error> {
        let _result = self.send_raw(state);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut state: CallState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CallWatchStateResponse>(
            (state,),
            self.tx_id,
            0x5262bcc909bdaeb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CallSendDtmfCodeResponder {
    control_handle: std::mem::ManuallyDrop<CallControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`CallControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for CallSendDtmfCodeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CallSendDtmfCodeResponder {
    type ControlHandle = CallControlHandle;

    fn control_handle(&self) -> &CallControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl CallSendDtmfCodeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x50768933ca33fcd6,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CallManagerMarker;

impl fidl::endpoints::ProtocolMarker for CallManagerMarker {
    type Proxy = CallManagerProxy;
    type RequestStream = CallManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CallManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) CallManager";
}

pub trait CallManagerProxyInterface: Send + Sync {
    type PeerConnectedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#peer_connected(
        &self,
        id: &fidl_fuchsia_bluetooth::PeerId,
        handle: fidl::endpoints::ServerEnd<PeerHandlerMarker>,
    ) -> Self::PeerConnectedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CallManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CallManagerSynchronousProxy {
    type Proxy = CallManagerProxy;
    type Protocol = CallManagerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl CallManagerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<CallManagerEvent, fidl::Error> {
        CallManagerEvent::decode(self.client.wait_for_event::<CallManagerMarker>(deadline)?)
    }

    /// Signal that a peer that supports the HFP Hands-Free role is connected.
    ///
    /// `id` is the unique identifier associated with the peer.
    /// `handle` is the channel that the call manager should use to manage
    /// a the peer. If the call manager does not intend to handle a given peer,
    /// it must close the handle with a `ZX_ERR_UNAVAILABLE` epitaph.
    ///
    /// Multiple concurrent PeerConnected requests can be made by the client.
    /// The empty response is used as a flow control mechanism to allow the
    /// client to limit the number of pending PeerConnected requests.
    pub fn r#peer_connected(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: fidl::endpoints::ServerEnd<PeerHandlerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            CallManagerPeerConnectedRequest,
            fidl::encoding::EmptyPayload,
            CallManagerMarker,
        >(
            (id, handle,),
            0x1431cc24b2980086,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

#[cfg(target_os = "fuchsia")]
impl From<CallManagerSynchronousProxy> for zx::NullableHandle {
    fn from(value: CallManagerSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for CallManagerSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for CallManagerSynchronousProxy {
    type Protocol = CallManagerMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<CallManagerMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct CallManagerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for CallManagerProxy {
    type Protocol = CallManagerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl CallManagerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.hfp/CallManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CallManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CallManagerEventStream {
        CallManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Signal that a peer that supports the HFP Hands-Free role is connected.
    ///
    /// `id` is the unique identifier associated with the peer.
    /// `handle` is the channel that the call manager should use to manage
    /// a the peer. If the call manager does not intend to handle a given peer,
    /// it must close the handle with a `ZX_ERR_UNAVAILABLE` epitaph.
    ///
    /// Multiple concurrent PeerConnected requests can be made by the client.
    /// The empty response is used as a flow control mechanism to allow the
    /// client to limit the number of pending PeerConnected requests.
    pub fn r#peer_connected(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: fidl::endpoints::ServerEnd<PeerHandlerMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        CallManagerProxyInterface::r#peer_connected(self, id, handle)
    }
}

impl CallManagerProxyInterface for CallManagerProxy {
    type PeerConnectedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#peer_connected(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: fidl::endpoints::ServerEnd<PeerHandlerMarker>,
    ) -> Self::PeerConnectedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1431cc24b2980086,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<CallManagerPeerConnectedRequest, ()>(
            (id, handle),
            0x1431cc24b2980086,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct CallManagerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for CallManagerEventStream {}

impl futures::stream::FusedStream for CallManagerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for CallManagerEventStream {
    type Item = Result<CallManagerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(CallManagerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum CallManagerEvent {}

impl CallManagerEvent {
    /// Decodes a message buffer as a [`CallManagerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<CallManagerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <CallManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.hfp/CallManager.
pub struct CallManagerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for CallManagerRequestStream {}

impl futures::stream::FusedStream for CallManagerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for CallManagerRequestStream {
    type Protocol = CallManagerMarker;
    type ControlHandle = CallManagerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        CallManagerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for CallManagerRequestStream {
    type Item = Result<CallManagerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled CallManagerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1431cc24b2980086 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CallManagerPeerConnectedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CallManagerPeerConnectedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CallManagerControlHandle { inner: this.inner.clone() };
                        Ok(CallManagerRequest::PeerConnected {
                            id: req.id,
                            handle: req.handle,

                            responder: CallManagerPeerConnectedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <CallManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum CallManagerRequest {
    /// Signal that a peer that supports the HFP Hands-Free role is connected.
    ///
    /// `id` is the unique identifier associated with the peer.
    /// `handle` is the channel that the call manager should use to manage
    /// a the peer. If the call manager does not intend to handle a given peer,
    /// it must close the handle with a `ZX_ERR_UNAVAILABLE` epitaph.
    ///
    /// Multiple concurrent PeerConnected requests can be made by the client.
    /// The empty response is used as a flow control mechanism to allow the
    /// client to limit the number of pending PeerConnected requests.
    PeerConnected {
        id: fidl_fuchsia_bluetooth::PeerId,
        handle: fidl::endpoints::ServerEnd<PeerHandlerMarker>,
        responder: CallManagerPeerConnectedResponder,
    },
}

impl CallManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_peer_connected(
        self,
    ) -> Option<(
        fidl_fuchsia_bluetooth::PeerId,
        fidl::endpoints::ServerEnd<PeerHandlerMarker>,
        CallManagerPeerConnectedResponder,
    )> {
        if let CallManagerRequest::PeerConnected { id, handle, responder } = self {
            Some((id, handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CallManagerRequest::PeerConnected { .. } => "peer_connected",
        }
    }
}

#[derive(Debug, Clone)]
pub struct CallManagerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for CallManagerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl CallManagerControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CallManagerPeerConnectedResponder {
    control_handle: std::mem::ManuallyDrop<CallManagerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`CallManagerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for CallManagerPeerConnectedResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CallManagerPeerConnectedResponder {
    type ControlHandle = CallManagerControlHandle;

    fn control_handle(&self) -> &CallManagerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl CallManagerPeerConnectedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x1431cc24b2980086,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct HandsFreeMarker;

impl fidl::endpoints::ProtocolMarker for HandsFreeMarker {
    type Proxy = HandsFreeProxy;
    type RequestStream = HandsFreeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HandsFreeSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.hfp.HandsFree";
}
impl fidl::endpoints::DiscoverableProtocolMarker for HandsFreeMarker {}
pub type HandsFreeWatchPeerConnectedResult =
    Result<(fidl_fuchsia_bluetooth::PeerId, fidl::endpoints::ClientEnd<PeerHandlerMarker>), i32>;

pub trait HandsFreeProxyInterface: Send + Sync {
    type WatchPeerConnectedResponseFut: std::future::Future<Output = Result<HandsFreeWatchPeerConnectedResult, fidl::Error>>
        + Send;
    fn r#watch_peer_connected(&self) -> Self::WatchPeerConnectedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HandsFreeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HandsFreeSynchronousProxy {
    type Proxy = HandsFreeProxy;
    type Protocol = HandsFreeMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl HandsFreeSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<HandsFreeEvent, fidl::Error> {
        HandsFreeEvent::decode(self.client.wait_for_event::<HandsFreeMarker>(deadline)?)
    }

    /// Hanging get that waits for a a peer that supports the HFP Audio Gateway
    /// role to connect.
    ///
    /// `id` is the unique identifier associated with the peer.
    ///
    /// `handle` is the channel that the client should use to manage the peer.
    /// If the call manager does not intend to handle a given peer. it must
    /// close the handle,
    pub fn r#watch_peer_connected(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HandsFreeWatchPeerConnectedResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<HandsFreeWatchPeerConnectedResponse, i32>,
            HandsFreeMarker,
        >(
            (),
            0x1cc503325a8bbc3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.id, x.handle)))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<HandsFreeSynchronousProxy> for zx::NullableHandle {
    fn from(value: HandsFreeSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for HandsFreeSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for HandsFreeSynchronousProxy {
    type Protocol = HandsFreeMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<HandsFreeMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct HandsFreeProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for HandsFreeProxy {
    type Protocol = HandsFreeMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl HandsFreeProxy {
    /// Create a new Proxy for fuchsia.bluetooth.hfp/HandsFree.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HandsFreeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> HandsFreeEventStream {
        HandsFreeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Hanging get that waits for a a peer that supports the HFP Audio Gateway
    /// role to connect.
    ///
    /// `id` is the unique identifier associated with the peer.
    ///
    /// `handle` is the channel that the client should use to manage the peer.
    /// If the call manager does not intend to handle a given peer. it must
    /// close the handle,
    pub fn r#watch_peer_connected(
        &self,
    ) -> fidl::client::QueryResponseFut<
        HandsFreeWatchPeerConnectedResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HandsFreeProxyInterface::r#watch_peer_connected(self)
    }
}

impl HandsFreeProxyInterface for HandsFreeProxy {
    type WatchPeerConnectedResponseFut = fidl::client::QueryResponseFut<
        HandsFreeWatchPeerConnectedResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_peer_connected(&self) -> Self::WatchPeerConnectedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HandsFreeWatchPeerConnectedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<HandsFreeWatchPeerConnectedResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cc503325a8bbc3f,
            >(_buf?)?;
            Ok(_response.map(|x| (x.id, x.handle)))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            HandsFreeWatchPeerConnectedResult,
        >(
            (),
            0x1cc503325a8bbc3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct HandsFreeEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for HandsFreeEventStream {}

impl futures::stream::FusedStream for HandsFreeEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for HandsFreeEventStream {
    type Item = Result<HandsFreeEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(HandsFreeEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum HandsFreeEvent {}

impl HandsFreeEvent {
    /// Decodes a message buffer as a [`HandsFreeEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<HandsFreeEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <HandsFreeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.hfp/HandsFree.
pub struct HandsFreeRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for HandsFreeRequestStream {}

impl futures::stream::FusedStream for HandsFreeRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for HandsFreeRequestStream {
    type Protocol = HandsFreeMarker;
    type ControlHandle = HandsFreeControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        HandsFreeControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for HandsFreeRequestStream {
    type Item = Result<HandsFreeRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled HandsFreeRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1cc503325a8bbc3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HandsFreeControlHandle { inner: this.inner.clone() };
                        Ok(HandsFreeRequest::WatchPeerConnected {
                            responder: HandsFreeWatchPeerConnectedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <HandsFreeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum HandsFreeRequest {
    /// Hanging get that waits for a a peer that supports the HFP Audio Gateway
    /// role to connect.
    ///
    /// `id` is the unique identifier associated with the peer.
    ///
    /// `handle` is the channel that the client should use to manage the peer.
    /// If the call manager does not intend to handle a given peer. it must
    /// close the handle,
    WatchPeerConnected { responder: HandsFreeWatchPeerConnectedResponder },
}

impl HandsFreeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_peer_connected(self) -> Option<(HandsFreeWatchPeerConnectedResponder)> {
        if let HandsFreeRequest::WatchPeerConnected { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            HandsFreeRequest::WatchPeerConnected { .. } => "watch_peer_connected",
        }
    }
}

#[derive(Debug, Clone)]
pub struct HandsFreeControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for HandsFreeControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl HandsFreeControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct HandsFreeWatchPeerConnectedResponder {
    control_handle: std::mem::ManuallyDrop<HandsFreeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`HandsFreeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for HandsFreeWatchPeerConnectedResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for HandsFreeWatchPeerConnectedResponder {
    type ControlHandle = HandsFreeControlHandle;

    fn control_handle(&self) -> &HandsFreeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl HandsFreeWatchPeerConnectedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<
            (&fidl_fuchsia_bluetooth::PeerId, fidl::endpoints::ClientEnd<PeerHandlerMarker>),
            i32,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<
            (&fidl_fuchsia_bluetooth::PeerId, fidl::endpoints::ClientEnd<PeerHandlerMarker>),
            i32,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<
            (&fidl_fuchsia_bluetooth::PeerId, fidl::endpoints::ClientEnd<PeerHandlerMarker>),
            i32,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            HandsFreeWatchPeerConnectedResponse,
            i32,
        >>(
            result,
            self.tx_id,
            0x1cc503325a8bbc3f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct HeadsetGainMarker;

impl fidl::endpoints::ProtocolMarker for HeadsetGainMarker {
    type Proxy = HeadsetGainProxy;
    type RequestStream = HeadsetGainRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HeadsetGainSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) HeadsetGain";
}

pub trait HeadsetGainProxyInterface: Send + Sync {
    fn r#set_speaker_gain(&self, requested: u8) -> Result<(), fidl::Error>;
    type WatchSpeakerGainResponseFut: std::future::Future<Output = Result<u8, fidl::Error>> + Send;
    fn r#watch_speaker_gain(&self) -> Self::WatchSpeakerGainResponseFut;
    fn r#set_microphone_gain(&self, requested: u8) -> Result<(), fidl::Error>;
    type WatchMicrophoneGainResponseFut: std::future::Future<Output = Result<u8, fidl::Error>>
        + Send;
    fn r#watch_microphone_gain(&self) -> Self::WatchMicrophoneGainResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HeadsetGainSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HeadsetGainSynchronousProxy {
    type Proxy = HeadsetGainProxy;
    type Protocol = HeadsetGainMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl HeadsetGainSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<HeadsetGainEvent, fidl::Error> {
        HeadsetGainEvent::decode(self.client.wait_for_event::<HeadsetGainMarker>(deadline)?)
    }

    /// Make a request to the headset to set the speaker gain to `requested`.
    ///
    /// `requested` must be in the range [0-15] inclusive. Any values outside of
    /// this range will result in the channel closing with a
    /// `ZX_ERR_INVALID_ARGUMENT` epitaph.
    pub fn r#set_speaker_gain(&self, mut requested: u8) -> Result<(), fidl::Error> {
        self.client.send::<HeadsetGainSetSpeakerGainRequest>(
            (requested,),
            0x3462191b2a6ae5ce,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Hanging get to watch for updates to the headset speaker gain. Responses
    /// represent the current gain value that is set.
    ///
    /// The returned `gain` value will always be in the range [0-15] inclusive.
    pub fn r#watch_speaker_gain(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u8, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            HeadsetGainWatchSpeakerGainResponse,
            HeadsetGainMarker,
        >(
            (),
            0x2007abdf2695c747,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.gain)
    }

    /// Make a request to the Headset to set the microphone gain to `requested`.
    ///
    /// `requested` must be in the range [0-15] inclusive. Any values outside of
    /// this range will result in the channel closing with a
    /// `ZX_ERR_INVALID_ARGUMENT` epitaph.
    pub fn r#set_microphone_gain(&self, mut requested: u8) -> Result<(), fidl::Error> {
        self.client.send::<HeadsetGainSetMicrophoneGainRequest>(
            (requested,),
            0x7ddbb4e63caeef8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Hanging get to watch for updates to the headset microphone gain. Responses
    /// represent the current gain value that is set.
    ///
    /// The returned `gain` value will always be in the range [0-15] inclusive.
    pub fn r#watch_microphone_gain(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u8, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            HeadsetGainWatchMicrophoneGainResponse,
            HeadsetGainMarker,
        >(
            (),
            0x1d171fb432fa55ad,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.gain)
    }
}

#[cfg(target_os = "fuchsia")]
impl From<HeadsetGainSynchronousProxy> for zx::NullableHandle {
    fn from(value: HeadsetGainSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for HeadsetGainSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for HeadsetGainSynchronousProxy {
    type Protocol = HeadsetGainMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<HeadsetGainMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct HeadsetGainProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for HeadsetGainProxy {
    type Protocol = HeadsetGainMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl HeadsetGainProxy {
    /// Create a new Proxy for fuchsia.bluetooth.hfp/HeadsetGain.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HeadsetGainMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> HeadsetGainEventStream {
        HeadsetGainEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Make a request to the headset to set the speaker gain to `requested`.
    ///
    /// `requested` must be in the range [0-15] inclusive. Any values outside of
    /// this range will result in the channel closing with a
    /// `ZX_ERR_INVALID_ARGUMENT` epitaph.
    pub fn r#set_speaker_gain(&self, mut requested: u8) -> Result<(), fidl::Error> {
        HeadsetGainProxyInterface::r#set_speaker_gain(self, requested)
    }

    /// Hanging get to watch for updates to the headset speaker gain. Responses
    /// represent the current gain value that is set.
    ///
    /// The returned `gain` value will always be in the range [0-15] inclusive.
    pub fn r#watch_speaker_gain(
        &self,
    ) -> fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect> {
        HeadsetGainProxyInterface::r#watch_speaker_gain(self)
    }

    /// Make a request to the Headset to set the microphone gain to `requested`.
    ///
    /// `requested` must be in the range [0-15] inclusive. Any values outside of
    /// this range will result in the channel closing with a
    /// `ZX_ERR_INVALID_ARGUMENT` epitaph.
    pub fn r#set_microphone_gain(&self, mut requested: u8) -> Result<(), fidl::Error> {
        HeadsetGainProxyInterface::r#set_microphone_gain(self, requested)
    }

    /// Hanging get to watch for updates to the headset microphone gain. Responses
    /// represent the current gain value that is set.
    ///
    /// The returned `gain` value will always be in the range [0-15] inclusive.
    pub fn r#watch_microphone_gain(
        &self,
    ) -> fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect> {
        HeadsetGainProxyInterface::r#watch_microphone_gain(self)
    }
}

impl HeadsetGainProxyInterface for HeadsetGainProxy {
    fn r#set_speaker_gain(&self, mut requested: u8) -> Result<(), fidl::Error> {
        self.client.send::<HeadsetGainSetSpeakerGainRequest>(
            (requested,),
            0x3462191b2a6ae5ce,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchSpeakerGainResponseFut =
        fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_speaker_gain(&self) -> Self::WatchSpeakerGainResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u8, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HeadsetGainWatchSpeakerGainResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2007abdf2695c747,
            >(_buf?)?;
            Ok(_response.gain)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u8>(
            (),
            0x2007abdf2695c747,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_microphone_gain(&self, mut requested: u8) -> Result<(), fidl::Error> {
        self.client.send::<HeadsetGainSetMicrophoneGainRequest>(
            (requested,),
            0x7ddbb4e63caeef8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchMicrophoneGainResponseFut =
        fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_microphone_gain(&self) -> Self::WatchMicrophoneGainResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u8, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HeadsetGainWatchMicrophoneGainResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1d171fb432fa55ad,
            >(_buf?)?;
            Ok(_response.gain)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u8>(
            (),
            0x1d171fb432fa55ad,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct HeadsetGainEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for HeadsetGainEventStream {}

impl futures::stream::FusedStream for HeadsetGainEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for HeadsetGainEventStream {
    type Item = Result<HeadsetGainEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(HeadsetGainEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum HeadsetGainEvent {}

impl HeadsetGainEvent {
    /// Decodes a message buffer as a [`HeadsetGainEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<HeadsetGainEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <HeadsetGainMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.hfp/HeadsetGain.
pub struct HeadsetGainRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for HeadsetGainRequestStream {}

impl futures::stream::FusedStream for HeadsetGainRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for HeadsetGainRequestStream {
    type Protocol = HeadsetGainMarker;
    type ControlHandle = HeadsetGainControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        HeadsetGainControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for HeadsetGainRequestStream {
    type Item = Result<HeadsetGainRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled HeadsetGainRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3462191b2a6ae5ce => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            HeadsetGainSetSpeakerGainRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HeadsetGainSetSpeakerGainRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HeadsetGainControlHandle { inner: this.inner.clone() };
                        Ok(HeadsetGainRequest::SetSpeakerGain {
                            requested: req.requested,

                            control_handle,
                        })
                    }
                    0x2007abdf2695c747 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HeadsetGainControlHandle { inner: this.inner.clone() };
                        Ok(HeadsetGainRequest::WatchSpeakerGain {
                            responder: HeadsetGainWatchSpeakerGainResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7ddbb4e63caeef8e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            HeadsetGainSetMicrophoneGainRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HeadsetGainSetMicrophoneGainRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HeadsetGainControlHandle { inner: this.inner.clone() };
                        Ok(HeadsetGainRequest::SetMicrophoneGain {
                            requested: req.requested,

                            control_handle,
                        })
                    }
                    0x1d171fb432fa55ad => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HeadsetGainControlHandle { inner: this.inner.clone() };
                        Ok(HeadsetGainRequest::WatchMicrophoneGain {
                            responder: HeadsetGainWatchMicrophoneGainResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <HeadsetGainMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Control Headset Speaker and Microphone gain and receive reports of current
/// values as specified in HFP v1.8, Section 4.29. This protocol is served by the
/// Hfp service.
///
/// Gain is represented as an absolute value on a scale from 0 to 15. 0 is the
/// minimum gain and 15 is the maximum gain. It is related to a particular
/// (implementation dependent) volume level controlled by the Headset.
///
///
/// Epitaphs:
///
/// This channel will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph if there
/// is already an active `HeadsetGain` channel.
///
/// This channel will be closed with a `ZX_ERR_NOT_SUPPORTED` epitaph if the Hfp
/// service is not configured to support remote volume control or the peer
/// headset does not support remote volume control. If the channel is closed
/// with this error, the client should not attempt to reopen it using the
/// `PeerHandler::GainControl` request on the same PeerHandler connection.
///
/// This channel will be closed with a `ZX_ERR_INVALID_ARGUMENT` epitaph if
/// invalid arguments are passed to requests. See documentation on specific
/// requests for more details.
#[derive(Debug)]
pub enum HeadsetGainRequest {
    /// Make a request to the headset to set the speaker gain to `requested`.
    ///
    /// `requested` must be in the range [0-15] inclusive. Any values outside of
    /// this range will result in the channel closing with a
    /// `ZX_ERR_INVALID_ARGUMENT` epitaph.
    SetSpeakerGain { requested: u8, control_handle: HeadsetGainControlHandle },
    /// Hanging get to watch for updates to the headset speaker gain. Responses
    /// represent the current gain value that is set.
    ///
    /// The returned `gain` value will always be in the range [0-15] inclusive.
    WatchSpeakerGain { responder: HeadsetGainWatchSpeakerGainResponder },
    /// Make a request to the Headset to set the microphone gain to `requested`.
    ///
    /// `requested` must be in the range [0-15] inclusive. Any values outside of
    /// this range will result in the channel closing with a
    /// `ZX_ERR_INVALID_ARGUMENT` epitaph.
    SetMicrophoneGain { requested: u8, control_handle: HeadsetGainControlHandle },
    /// Hanging get to watch for updates to the headset microphone gain. Responses
    /// represent the current gain value that is set.
    ///
    /// The returned `gain` value will always be in the range [0-15] inclusive.
    WatchMicrophoneGain { responder: HeadsetGainWatchMicrophoneGainResponder },
}

impl HeadsetGainRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_speaker_gain(self) -> Option<(u8, HeadsetGainControlHandle)> {
        if let HeadsetGainRequest::SetSpeakerGain { requested, control_handle } = self {
            Some((requested, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_speaker_gain(self) -> Option<(HeadsetGainWatchSpeakerGainResponder)> {
        if let HeadsetGainRequest::WatchSpeakerGain { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_microphone_gain(self) -> Option<(u8, HeadsetGainControlHandle)> {
        if let HeadsetGainRequest::SetMicrophoneGain { requested, control_handle } = self {
            Some((requested, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_microphone_gain(self) -> Option<(HeadsetGainWatchMicrophoneGainResponder)> {
        if let HeadsetGainRequest::WatchMicrophoneGain { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            HeadsetGainRequest::SetSpeakerGain { .. } => "set_speaker_gain",
            HeadsetGainRequest::WatchSpeakerGain { .. } => "watch_speaker_gain",
            HeadsetGainRequest::SetMicrophoneGain { .. } => "set_microphone_gain",
            HeadsetGainRequest::WatchMicrophoneGain { .. } => "watch_microphone_gain",
        }
    }
}

#[derive(Debug, Clone)]
pub struct HeadsetGainControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for HeadsetGainControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl HeadsetGainControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct HeadsetGainWatchSpeakerGainResponder {
    control_handle: std::mem::ManuallyDrop<HeadsetGainControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`HeadsetGainControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for HeadsetGainWatchSpeakerGainResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for HeadsetGainWatchSpeakerGainResponder {
    type ControlHandle = HeadsetGainControlHandle;

    fn control_handle(&self) -> &HeadsetGainControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl HeadsetGainWatchSpeakerGainResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut gain: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(gain);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut gain: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(gain);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut gain: u8) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HeadsetGainWatchSpeakerGainResponse>(
            (gain,),
            self.tx_id,
            0x2007abdf2695c747,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct HeadsetGainWatchMicrophoneGainResponder {
    control_handle: std::mem::ManuallyDrop<HeadsetGainControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`HeadsetGainControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for HeadsetGainWatchMicrophoneGainResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for HeadsetGainWatchMicrophoneGainResponder {
    type ControlHandle = HeadsetGainControlHandle;

    fn control_handle(&self) -> &HeadsetGainControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl HeadsetGainWatchMicrophoneGainResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut gain: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(gain);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut gain: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(gain);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut gain: u8) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HeadsetGainWatchMicrophoneGainResponse>(
            (gain,),
            self.tx_id,
            0x1d171fb432fa55ad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct HfpMarker;

impl fidl::endpoints::ProtocolMarker for HfpMarker {
    type Proxy = HfpProxy;
    type RequestStream = HfpRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HfpSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.hfp.Hfp";
}
impl fidl::endpoints::DiscoverableProtocolMarker for HfpMarker {}

pub trait HfpProxyInterface: Send + Sync {
    fn r#register(
        &self,
        manager: fidl::endpoints::ClientEnd<CallManagerMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HfpSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HfpSynchronousProxy {
    type Proxy = HfpProxy;
    type Protocol = HfpMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl HfpSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<HfpEvent, fidl::Error> {
        HfpEvent::decode(self.client.wait_for_event::<HfpMarker>(deadline)?)
    }

    /// Register as the call manager for this device.
    ///
    /// There can only be one call manager registered at a time. If one is
    /// registered at the time a call to `Register` is made, the newer
    /// CallManager channel will be closed.
    ///
    /// A call manager can be unregistered by closing either end of the channel.
    pub fn r#register(
        &self,
        mut manager: fidl::endpoints::ClientEnd<CallManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<HfpRegisterRequest>(
            (manager,),
            0x1b2ea4f6069181ad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[cfg(target_os = "fuchsia")]
impl From<HfpSynchronousProxy> for zx::NullableHandle {
    fn from(value: HfpSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for HfpSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for HfpSynchronousProxy {
    type Protocol = HfpMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<HfpMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct HfpProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for HfpProxy {
    type Protocol = HfpMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl HfpProxy {
    /// Create a new Proxy for fuchsia.bluetooth.hfp/Hfp.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HfpMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> HfpEventStream {
        HfpEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Register as the call manager for this device.
    ///
    /// There can only be one call manager registered at a time. If one is
    /// registered at the time a call to `Register` is made, the newer
    /// CallManager channel will be closed.
    ///
    /// A call manager can be unregistered by closing either end of the channel.
    pub fn r#register(
        &self,
        mut manager: fidl::endpoints::ClientEnd<CallManagerMarker>,
    ) -> Result<(), fidl::Error> {
        HfpProxyInterface::r#register(self, manager)
    }
}

impl HfpProxyInterface for HfpProxy {
    fn r#register(
        &self,
        mut manager: fidl::endpoints::ClientEnd<CallManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<HfpRegisterRequest>(
            (manager,),
            0x1b2ea4f6069181ad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct HfpEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for HfpEventStream {}

impl futures::stream::FusedStream for HfpEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for HfpEventStream {
    type Item = Result<HfpEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(HfpEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum HfpEvent {}

impl HfpEvent {
    /// Decodes a message buffer as a [`HfpEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<HfpEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <HfpMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.hfp/Hfp.
pub struct HfpRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for HfpRequestStream {}

impl futures::stream::FusedStream for HfpRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for HfpRequestStream {
    type Protocol = HfpMarker;
    type ControlHandle = HfpControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        HfpControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for HfpRequestStream {
    type Item = Result<HfpRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled HfpRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1b2ea4f6069181ad => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            HfpRegisterRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HfpRegisterRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HfpControlHandle { inner: this.inner.clone() };
                        Ok(HfpRequest::Register { manager: req.manager, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <HfpMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum HfpRequest {
    /// Register as the call manager for this device.
    ///
    /// There can only be one call manager registered at a time. If one is
    /// registered at the time a call to `Register` is made, the newer
    /// CallManager channel will be closed.
    ///
    /// A call manager can be unregistered by closing either end of the channel.
    Register {
        manager: fidl::endpoints::ClientEnd<CallManagerMarker>,
        control_handle: HfpControlHandle,
    },
}

impl HfpRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<CallManagerMarker>, HfpControlHandle)> {
        if let HfpRequest::Register { manager, control_handle } = self {
            Some((manager, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            HfpRequest::Register { .. } => "register",
        }
    }
}

#[derive(Debug, Clone)]
pub struct HfpControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for HfpControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl HfpControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct PeerHandlerMarker;

impl fidl::endpoints::ProtocolMarker for PeerHandlerMarker {
    type Proxy = PeerHandlerProxy;
    type RequestStream = PeerHandlerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PeerHandlerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) PeerHandler";
}
pub type PeerHandlerRequestOutgoingCallResult = Result<(), i32>;
pub type PeerHandlerSetNrecModeResult = Result<(), i32>;

pub trait PeerHandlerProxyInterface: Send + Sync {
    type WatchNetworkInformationResponseFut: std::future::Future<Output = Result<NetworkInformation, fidl::Error>>
        + Send;
    fn r#watch_network_information(&self) -> Self::WatchNetworkInformationResponseFut;
    type WatchNextCallResponseFut: std::future::Future<Output = Result<NextCall, fidl::Error>>
        + Send;
    fn r#watch_next_call(&self) -> Self::WatchNextCallResponseFut;
    type RequestOutgoingCallResponseFut: std::future::Future<Output = Result<PeerHandlerRequestOutgoingCallResult, fidl::Error>>
        + Send;
    fn r#request_outgoing_call(&self, action: &CallAction) -> Self::RequestOutgoingCallResponseFut;
    type QueryOperatorResponseFut: std::future::Future<Output = Result<Option<String>, fidl::Error>>
        + Send;
    fn r#query_operator(&self) -> Self::QueryOperatorResponseFut;
    type SubscriberNumberInformationResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
        + Send;
    fn r#subscriber_number_information(&self) -> Self::SubscriberNumberInformationResponseFut;
    type SetNrecModeResponseFut: std::future::Future<Output = Result<PeerHandlerSetNrecModeResult, fidl::Error>>
        + Send;
    fn r#set_nrec_mode(&self, enabled: bool) -> Self::SetNrecModeResponseFut;
    fn r#report_headset_battery_level(&self, level: u8) -> Result<(), fidl::Error>;
    fn r#gain_control(
        &self,
        control: fidl::endpoints::ClientEnd<HeadsetGainMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PeerHandlerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PeerHandlerSynchronousProxy {
    type Proxy = PeerHandlerProxy;
    type Protocol = PeerHandlerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl PeerHandlerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<PeerHandlerEvent, fidl::Error> {
        PeerHandlerEvent::decode(self.client.wait_for_event::<PeerHandlerMarker>(deadline)?)
    }

    /// Hanging get to provide the Hfp service with an `update` on the
    /// `NetworkInformation`. Any fields in `update` that are not present will
    /// be treated as unmodified by the update.
    ///
    /// The call manager or audio gateway peer _should_ provide a fully
    /// populated `update` when it is called for the first time.
    ///
    /// The most up-to-date `NetworkInformation` is used during the connection
    /// initialization process of the peer, and updates are propagated to the
    /// peer if it supports AG Indicators.
    pub fn r#watch_network_information(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NetworkInformation, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PeerHandlerWatchNetworkInformationResponse,
            PeerHandlerMarker,
        >(
            (),
            0x1c9eba597076b7cb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.update)
    }

    /// Hanging get which returns when a new call is initiated by the call
    /// manager or audio gateway peer, or an ongoing call is transferred to the
    /// headset.  `RequestOutgoingCall` can be called before or after
    /// `WatchNextCall`.
    pub fn r#watch_next_call(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NextCall, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PeerHandlerWatchNextCallResponse,
            PeerHandlerMarker,
        >(
            (),
            0x5e3b7b4e7c3d359,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.call)
    }

    /// Used to request an outgoing call be initiated by the call manager or
    /// audio gateway peer.  `RequestOutgoingCall` shall complete after the
    /// outgoing call has been initiated and the corresponding `Call` protocol
    /// has been returned via a `WatchNextCall` result.
    ///
    /// An error is returned if the call could not be placed as requested.
    ///
    /// - ZX_ERR_NOT_SUPPORTED can be used if the system does not support the
    ///   requested action.
    ///
    /// - ZX_ERR_ALREADY_EXISTS can be used if there is alreadya call in
    ///   progress and the system does not support additional calls.
    pub fn r#request_outgoing_call(
        &self,
        mut action: &CallAction,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerHandlerRequestOutgoingCallResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerHandlerRequestOutgoingCallRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PeerHandlerMarker,
        >(
            (action,),
            0x1a2637c743c89ad,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Request the name of the network operator for the call manager or audio
    /// gateway peer. A null value is returned if there is no operator name
    /// available.
    pub fn r#query_operator(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<String>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PeerHandlerQueryOperatorResponse,
            PeerHandlerMarker,
        >(
            (),
            0x1217eaf5db4c3300,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.operator)
    }

    /// Request subscriber numbers from the call manager or audio gateway peer.
    /// There can be zero or more numbers returned. Sending more than 128
    /// numbers is not supported at this time.
    pub fn r#subscriber_number_information(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<String>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PeerHandlerSubscriberNumberInformationResponse,
            PeerHandlerMarker,
        >(
            (),
            0x15f5235855b02a3a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.numbers)
    }

    /// Request by the HF to enable or disable the Noise Reduction/Echo Cancellation
    /// functionality on the AG based on the `enabled` boolean.
    /// A `ZX_ERR_NOT_SUPPORTED` error is returned if Noice Reduction/Echo
    /// Cancellation is not supported by the device.
    pub fn r#set_nrec_mode(
        &self,
        mut enabled: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerHandlerSetNrecModeResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerHandlerSetNrecModeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PeerHandlerMarker,
        >(
            (enabled,),
            0x2f8890d0f866672f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Headset battery level from 0 ~ 100
    /// See https://www.bluetooth.com/specifications/assigned-numbers/hands-free-profile/
    pub fn r#report_headset_battery_level(&self, mut level: u8) -> Result<(), fidl::Error> {
        self.client.send::<PeerHandlerReportHeadsetBatteryLevelRequest>(
            (level,),
            0x4e3e8be4680d85b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Tear off protocol for Headset Gain.
    ///
    /// Only one HeadsetGain protocol can be active for a PeerHandler protocol
    /// at any given time. Older HeadsetGain protocols are given preference. If
    /// a HeadsetGain protocol is active when a new GainControl request is made,
    /// the new HeadsetGain protocol will be closed immediately.
    pub fn r#gain_control(
        &self,
        mut control: fidl::endpoints::ClientEnd<HeadsetGainMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PeerHandlerGainControlRequest>(
            (control,),
            0x6e043b6d2e0fb917,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[cfg(target_os = "fuchsia")]
impl From<PeerHandlerSynchronousProxy> for zx::NullableHandle {
    fn from(value: PeerHandlerSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for PeerHandlerSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for PeerHandlerSynchronousProxy {
    type Protocol = PeerHandlerMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<PeerHandlerMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct PeerHandlerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for PeerHandlerProxy {
    type Protocol = PeerHandlerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl PeerHandlerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.hfp/PeerHandler.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PeerHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> PeerHandlerEventStream {
        PeerHandlerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Hanging get to provide the Hfp service with an `update` on the
    /// `NetworkInformation`. Any fields in `update` that are not present will
    /// be treated as unmodified by the update.
    ///
    /// The call manager or audio gateway peer _should_ provide a fully
    /// populated `update` when it is called for the first time.
    ///
    /// The most up-to-date `NetworkInformation` is used during the connection
    /// initialization process of the peer, and updates are propagated to the
    /// peer if it supports AG Indicators.
    pub fn r#watch_network_information(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NetworkInformation,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerHandlerProxyInterface::r#watch_network_information(self)
    }

    /// Hanging get which returns when a new call is initiated by the call
    /// manager or audio gateway peer, or an ongoing call is transferred to the
    /// headset.  `RequestOutgoingCall` can be called before or after
    /// `WatchNextCall`.
    pub fn r#watch_next_call(
        &self,
    ) -> fidl::client::QueryResponseFut<NextCall, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PeerHandlerProxyInterface::r#watch_next_call(self)
    }

    /// Used to request an outgoing call be initiated by the call manager or
    /// audio gateway peer.  `RequestOutgoingCall` shall complete after the
    /// outgoing call has been initiated and the corresponding `Call` protocol
    /// has been returned via a `WatchNextCall` result.
    ///
    /// An error is returned if the call could not be placed as requested.
    ///
    /// - ZX_ERR_NOT_SUPPORTED can be used if the system does not support the
    ///   requested action.
    ///
    /// - ZX_ERR_ALREADY_EXISTS can be used if there is alreadya call in
    ///   progress and the system does not support additional calls.
    pub fn r#request_outgoing_call(
        &self,
        mut action: &CallAction,
    ) -> fidl::client::QueryResponseFut<
        PeerHandlerRequestOutgoingCallResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerHandlerProxyInterface::r#request_outgoing_call(self, action)
    }

    /// Request the name of the network operator for the call manager or audio
    /// gateway peer. A null value is returned if there is no operator name
    /// available.
    pub fn r#query_operator(
        &self,
    ) -> fidl::client::QueryResponseFut<Option<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PeerHandlerProxyInterface::r#query_operator(self)
    }

    /// Request subscriber numbers from the call manager or audio gateway peer.
    /// There can be zero or more numbers returned. Sending more than 128
    /// numbers is not supported at this time.
    pub fn r#subscriber_number_information(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PeerHandlerProxyInterface::r#subscriber_number_information(self)
    }

    /// Request by the HF to enable or disable the Noise Reduction/Echo Cancellation
    /// functionality on the AG based on the `enabled` boolean.
    /// A `ZX_ERR_NOT_SUPPORTED` error is returned if Noice Reduction/Echo
    /// Cancellation is not supported by the device.
    pub fn r#set_nrec_mode(
        &self,
        mut enabled: bool,
    ) -> fidl::client::QueryResponseFut<
        PeerHandlerSetNrecModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerHandlerProxyInterface::r#set_nrec_mode(self, enabled)
    }

    /// Headset battery level from 0 ~ 100
    /// See https://www.bluetooth.com/specifications/assigned-numbers/hands-free-profile/
    pub fn r#report_headset_battery_level(&self, mut level: u8) -> Result<(), fidl::Error> {
        PeerHandlerProxyInterface::r#report_headset_battery_level(self, level)
    }

    /// Tear off protocol for Headset Gain.
    ///
    /// Only one HeadsetGain protocol can be active for a PeerHandler protocol
    /// at any given time. Older HeadsetGain protocols are given preference. If
    /// a HeadsetGain protocol is active when a new GainControl request is made,
    /// the new HeadsetGain protocol will be closed immediately.
    pub fn r#gain_control(
        &self,
        mut control: fidl::endpoints::ClientEnd<HeadsetGainMarker>,
    ) -> Result<(), fidl::Error> {
        PeerHandlerProxyInterface::r#gain_control(self, control)
    }
}

impl PeerHandlerProxyInterface for PeerHandlerProxy {
    type WatchNetworkInformationResponseFut = fidl::client::QueryResponseFut<
        NetworkInformation,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_network_information(&self) -> Self::WatchNetworkInformationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NetworkInformation, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PeerHandlerWatchNetworkInformationResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1c9eba597076b7cb,
            >(_buf?)?;
            Ok(_response.update)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NetworkInformation>(
            (),
            0x1c9eba597076b7cb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchNextCallResponseFut =
        fidl::client::QueryResponseFut<NextCall, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_next_call(&self) -> Self::WatchNextCallResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NextCall, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PeerHandlerWatchNextCallResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5e3b7b4e7c3d359,
            >(_buf?)?;
            Ok(_response.call)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NextCall>(
            (),
            0x5e3b7b4e7c3d359,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RequestOutgoingCallResponseFut = fidl::client::QueryResponseFut<
        PeerHandlerRequestOutgoingCallResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#request_outgoing_call(
        &self,
        mut action: &CallAction,
    ) -> Self::RequestOutgoingCallResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerHandlerRequestOutgoingCallResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1a2637c743c89ad,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeerHandlerRequestOutgoingCallRequest,
            PeerHandlerRequestOutgoingCallResult,
        >(
            (action,),
            0x1a2637c743c89ad,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryOperatorResponseFut = fidl::client::QueryResponseFut<
        Option<String>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_operator(&self) -> Self::QueryOperatorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PeerHandlerQueryOperatorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1217eaf5db4c3300,
            >(_buf?)?;
            Ok(_response.operator)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Option<String>>(
            (),
            0x1217eaf5db4c3300,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SubscriberNumberInformationResponseFut =
        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#subscriber_number_information(&self) -> Self::SubscriberNumberInformationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PeerHandlerSubscriberNumberInformationResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x15f5235855b02a3a,
            >(_buf?)?;
            Ok(_response.numbers)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
            (),
            0x15f5235855b02a3a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNrecModeResponseFut = fidl::client::QueryResponseFut<
        PeerHandlerSetNrecModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_nrec_mode(&self, mut enabled: bool) -> Self::SetNrecModeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerHandlerSetNrecModeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2f8890d0f866672f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<PeerHandlerSetNrecModeRequest, PeerHandlerSetNrecModeResult>(
                (enabled,),
                0x2f8890d0f866672f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#report_headset_battery_level(&self, mut level: u8) -> Result<(), fidl::Error> {
        self.client.send::<PeerHandlerReportHeadsetBatteryLevelRequest>(
            (level,),
            0x4e3e8be4680d85b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#gain_control(
        &self,
        mut control: fidl::endpoints::ClientEnd<HeadsetGainMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PeerHandlerGainControlRequest>(
            (control,),
            0x6e043b6d2e0fb917,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct PeerHandlerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for PeerHandlerEventStream {}

impl futures::stream::FusedStream for PeerHandlerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for PeerHandlerEventStream {
    type Item = Result<PeerHandlerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(PeerHandlerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum PeerHandlerEvent {}

impl PeerHandlerEvent {
    /// Decodes a message buffer as a [`PeerHandlerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PeerHandlerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <PeerHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.hfp/PeerHandler.
pub struct PeerHandlerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for PeerHandlerRequestStream {}

impl futures::stream::FusedStream for PeerHandlerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for PeerHandlerRequestStream {
    type Protocol = PeerHandlerMarker;
    type ControlHandle = PeerHandlerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        PeerHandlerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for PeerHandlerRequestStream {
    type Item = Result<PeerHandlerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PeerHandlerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1c9eba597076b7cb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::WatchNetworkInformation {
                            responder: PeerHandlerWatchNetworkInformationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5e3b7b4e7c3d359 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::WatchNextCall {
                            responder: PeerHandlerWatchNextCallResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1a2637c743c89ad => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerHandlerRequestOutgoingCallRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerHandlerRequestOutgoingCallRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::RequestOutgoingCall {
                            action: req.action,

                            responder: PeerHandlerRequestOutgoingCallResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1217eaf5db4c3300 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::QueryOperator {
                            responder: PeerHandlerQueryOperatorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x15f5235855b02a3a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::SubscriberNumberInformation {
                            responder: PeerHandlerSubscriberNumberInformationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f8890d0f866672f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerHandlerSetNrecModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerHandlerSetNrecModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::SetNrecMode {
                            enabled: req.enabled,

                            responder: PeerHandlerSetNrecModeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4e3e8be4680d85b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PeerHandlerReportHeadsetBatteryLevelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerHandlerReportHeadsetBatteryLevelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::ReportHeadsetBatteryLevel {
                            level: req.level,

                            control_handle,
                        })
                    }
                    0x6e043b6d2e0fb917 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PeerHandlerGainControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerHandlerGainControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerHandlerControlHandle { inner: this.inner.clone() };
                        Ok(PeerHandlerRequest::GainControl { control: req.control, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PeerHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The call manager or the hands-free server component will serve a call
/// handler protocol for each connected headset that it chooses to manage calls
/// through.
///
/// If the peer handler is closed by either channel endpoint, all protocols
/// associated with this peer handler are closed. This includes any Call, and
/// HeadsetGain protocols. Channels closed by a server end will include an
/// epitaph `ZX_ERR_HANDLE_CLOSED` in this situation.
#[derive(Debug)]
pub enum PeerHandlerRequest {
    /// Hanging get to provide the Hfp service with an `update` on the
    /// `NetworkInformation`. Any fields in `update` that are not present will
    /// be treated as unmodified by the update.
    ///
    /// The call manager or audio gateway peer _should_ provide a fully
    /// populated `update` when it is called for the first time.
    ///
    /// The most up-to-date `NetworkInformation` is used during the connection
    /// initialization process of the peer, and updates are propagated to the
    /// peer if it supports AG Indicators.
    WatchNetworkInformation { responder: PeerHandlerWatchNetworkInformationResponder },
    /// Hanging get which returns when a new call is initiated by the call
    /// manager or audio gateway peer, or an ongoing call is transferred to the
    /// headset.  `RequestOutgoingCall` can be called before or after
    /// `WatchNextCall`.
    WatchNextCall { responder: PeerHandlerWatchNextCallResponder },
    /// Used to request an outgoing call be initiated by the call manager or
    /// audio gateway peer.  `RequestOutgoingCall` shall complete after the
    /// outgoing call has been initiated and the corresponding `Call` protocol
    /// has been returned via a `WatchNextCall` result.
    ///
    /// An error is returned if the call could not be placed as requested.
    ///
    /// - ZX_ERR_NOT_SUPPORTED can be used if the system does not support the
    ///   requested action.
    ///
    /// - ZX_ERR_ALREADY_EXISTS can be used if there is alreadya call in
    ///   progress and the system does not support additional calls.
    RequestOutgoingCall { action: CallAction, responder: PeerHandlerRequestOutgoingCallResponder },
    /// Request the name of the network operator for the call manager or audio
    /// gateway peer. A null value is returned if there is no operator name
    /// available.
    QueryOperator { responder: PeerHandlerQueryOperatorResponder },
    /// Request subscriber numbers from the call manager or audio gateway peer.
    /// There can be zero or more numbers returned. Sending more than 128
    /// numbers is not supported at this time.
    SubscriberNumberInformation { responder: PeerHandlerSubscriberNumberInformationResponder },
    /// Request by the HF to enable or disable the Noise Reduction/Echo Cancellation
    /// functionality on the AG based on the `enabled` boolean.
    /// A `ZX_ERR_NOT_SUPPORTED` error is returned if Noice Reduction/Echo
    /// Cancellation is not supported by the device.
    SetNrecMode { enabled: bool, responder: PeerHandlerSetNrecModeResponder },
    /// Headset battery level from 0 ~ 100
    /// See https://www.bluetooth.com/specifications/assigned-numbers/hands-free-profile/
    ReportHeadsetBatteryLevel { level: u8, control_handle: PeerHandlerControlHandle },
    /// Tear off protocol for Headset Gain.
    ///
    /// Only one HeadsetGain protocol can be active for a PeerHandler protocol
    /// at any given time. Older HeadsetGain protocols are given preference. If
    /// a HeadsetGain protocol is active when a new GainControl request is made,
    /// the new HeadsetGain protocol will be closed immediately.
    GainControl {
        control: fidl::endpoints::ClientEnd<HeadsetGainMarker>,
        control_handle: PeerHandlerControlHandle,
    },
}

impl PeerHandlerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_network_information(
        self,
    ) -> Option<(PeerHandlerWatchNetworkInformationResponder)> {
        if let PeerHandlerRequest::WatchNetworkInformation { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_next_call(self) -> Option<(PeerHandlerWatchNextCallResponder)> {
        if let PeerHandlerRequest::WatchNextCall { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_outgoing_call(
        self,
    ) -> Option<(CallAction, PeerHandlerRequestOutgoingCallResponder)> {
        if let PeerHandlerRequest::RequestOutgoingCall { action, responder } = self {
            Some((action, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_operator(self) -> Option<(PeerHandlerQueryOperatorResponder)> {
        if let PeerHandlerRequest::QueryOperator { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_subscriber_number_information(
        self,
    ) -> Option<(PeerHandlerSubscriberNumberInformationResponder)> {
        if let PeerHandlerRequest::SubscriberNumberInformation { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_nrec_mode(self) -> Option<(bool, PeerHandlerSetNrecModeResponder)> {
        if let PeerHandlerRequest::SetNrecMode { enabled, responder } = self {
            Some((enabled, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_report_headset_battery_level(self) -> Option<(u8, PeerHandlerControlHandle)> {
        if let PeerHandlerRequest::ReportHeadsetBatteryLevel { level, control_handle } = self {
            Some((level, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_gain_control(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<HeadsetGainMarker>, PeerHandlerControlHandle)> {
        if let PeerHandlerRequest::GainControl { control, control_handle } = self {
            Some((control, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PeerHandlerRequest::WatchNetworkInformation { .. } => "watch_network_information",
            PeerHandlerRequest::WatchNextCall { .. } => "watch_next_call",
            PeerHandlerRequest::RequestOutgoingCall { .. } => "request_outgoing_call",
            PeerHandlerRequest::QueryOperator { .. } => "query_operator",
            PeerHandlerRequest::SubscriberNumberInformation { .. } => {
                "subscriber_number_information"
            }
            PeerHandlerRequest::SetNrecMode { .. } => "set_nrec_mode",
            PeerHandlerRequest::ReportHeadsetBatteryLevel { .. } => "report_headset_battery_level",
            PeerHandlerRequest::GainControl { .. } => "gain_control",
        }
    }
}

#[derive(Debug, Clone)]
pub struct PeerHandlerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for PeerHandlerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl PeerHandlerControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PeerHandlerWatchNetworkInformationResponder {
    control_handle: std::mem::ManuallyDrop<PeerHandlerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PeerHandlerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PeerHandlerWatchNetworkInformationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PeerHandlerWatchNetworkInformationResponder {
    type ControlHandle = PeerHandlerControlHandle;

    fn control_handle(&self) -> &PeerHandlerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PeerHandlerWatchNetworkInformationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut update: &NetworkInformation) -> Result<(), fidl::Error> {
        let _result = self.send_raw(update);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut update: &NetworkInformation,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(update);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut update: &NetworkInformation) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PeerHandlerWatchNetworkInformationResponse>(
            (update,),
            self.tx_id,
            0x1c9eba597076b7cb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PeerHandlerWatchNextCallResponder {
    control_handle: std::mem::ManuallyDrop<PeerHandlerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PeerHandlerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PeerHandlerWatchNextCallResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PeerHandlerWatchNextCallResponder {
    type ControlHandle = PeerHandlerControlHandle;

    fn control_handle(&self) -> &PeerHandlerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PeerHandlerWatchNextCallResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut call: NextCall) -> Result<(), fidl::Error> {
        let _result = self.send_raw(call);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut call: NextCall) -> Result<(), fidl::Error> {
        let _result = self.send_raw(call);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut call: NextCall) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PeerHandlerWatchNextCallResponse>(
            (&mut call,),
            self.tx_id,
            0x5e3b7b4e7c3d359,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PeerHandlerRequestOutgoingCallResponder {
    control_handle: std::mem::ManuallyDrop<PeerHandlerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PeerHandlerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PeerHandlerRequestOutgoingCallResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PeerHandlerRequestOutgoingCallResponder {
    type ControlHandle = PeerHandlerControlHandle;

    fn control_handle(&self) -> &PeerHandlerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PeerHandlerRequestOutgoingCallResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x1a2637c743c89ad,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PeerHandlerQueryOperatorResponder {
    control_handle: std::mem::ManuallyDrop<PeerHandlerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PeerHandlerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PeerHandlerQueryOperatorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PeerHandlerQueryOperatorResponder {
    type ControlHandle = PeerHandlerControlHandle;

    fn control_handle(&self) -> &PeerHandlerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PeerHandlerQueryOperatorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut operator: Option<&str>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(operator);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut operator: Option<&str>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(operator);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut operator: Option<&str>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PeerHandlerQueryOperatorResponse>(
            (operator,),
            self.tx_id,
            0x1217eaf5db4c3300,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PeerHandlerSubscriberNumberInformationResponder {
    control_handle: std::mem::ManuallyDrop<PeerHandlerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PeerHandlerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PeerHandlerSubscriberNumberInformationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PeerHandlerSubscriberNumberInformationResponder {
    type ControlHandle = PeerHandlerControlHandle;

    fn control_handle(&self) -> &PeerHandlerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PeerHandlerSubscriberNumberInformationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut numbers: &[String]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(numbers);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut numbers: &[String]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(numbers);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut numbers: &[String]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PeerHandlerSubscriberNumberInformationResponse>(
            (numbers,),
            self.tx_id,
            0x15f5235855b02a3a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PeerHandlerSetNrecModeResponder {
    control_handle: std::mem::ManuallyDrop<PeerHandlerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PeerHandlerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PeerHandlerSetNrecModeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PeerHandlerSetNrecModeResponder {
    type ControlHandle = PeerHandlerControlHandle;

    fn control_handle(&self) -> &PeerHandlerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PeerHandlerSetNrecModeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x2f8890d0f866672f,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for CallManagerPeerConnectedRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CallManagerPeerConnectedRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            CallManagerPeerConnectedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CallManagerPeerConnectedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CallManagerPeerConnectedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CallManagerPeerConnectedRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_bluetooth::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PeerHandlerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl_fuchsia_bluetooth::PeerId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PeerHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CallManagerPeerConnectedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CallManagerPeerConnectedRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CallManagerPeerConnectedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(
                    fidl_fuchsia_bluetooth::PeerId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                handle: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PeerHandlerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_bluetooth::PeerId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PeerHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for HandsFreeWatchPeerConnectedResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for HandsFreeWatchPeerConnectedResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            HandsFreeWatchPeerConnectedResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut HandsFreeWatchPeerConnectedResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HandsFreeWatchPeerConnectedResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<HandsFreeWatchPeerConnectedResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_bluetooth::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PeerHandlerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl_fuchsia_bluetooth::PeerId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PeerHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            HandsFreeWatchPeerConnectedResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HandsFreeWatchPeerConnectedResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for HandsFreeWatchPeerConnectedResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(
                    fidl_fuchsia_bluetooth::PeerId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                handle: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PeerHandlerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_bluetooth::PeerId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PeerHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for HfpRegisterRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for HfpRegisterRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<HfpRegisterRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut HfpRegisterRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HfpRegisterRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<HfpRegisterRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallManagerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.manager),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallManagerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<HfpRegisterRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HfpRegisterRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for HfpRegisterRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                manager: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallManagerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallManagerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.manager,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PeerHandlerGainControlRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PeerHandlerGainControlRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            PeerHandlerGainControlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeerHandlerGainControlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeerHandlerGainControlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PeerHandlerGainControlRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HeadsetGainMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.control),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HeadsetGainMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PeerHandlerGainControlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeerHandlerGainControlRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PeerHandlerGainControlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                control: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HeadsetGainMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HeadsetGainMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.control,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PeerHandlerWatchNextCallResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PeerHandlerWatchNextCallResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            PeerHandlerWatchNextCallResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeerHandlerWatchNextCallResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeerHandlerWatchNextCallResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PeerHandlerWatchNextCallResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<NextCall as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.call),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<NextCall, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            PeerHandlerWatchNextCallResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeerHandlerWatchNextCallResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PeerHandlerWatchNextCallResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { call: fidl::new_empty!(NextCall, fidl::encoding::DefaultFuchsiaResourceDialect) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                NextCall,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.call,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl NextCall {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.direction {
                return 4;
            }
            if let Some(_) = self.state {
                return 3;
            }
            if let Some(_) = self.remote {
                return 2;
            }
            if let Some(_) = self.call {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NextCall {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NextCall {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl fidl::encoding::Encode<NextCall, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NextCall
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NextCall>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.call.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::BoundedString<256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.remote.as_ref().map(
                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                CallState,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.state.as_ref().map(<CallState as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                CallDirection,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.direction
                    .as_ref()
                    .map(<CallDirection as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for NextCall {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<CallMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.call.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallMarker>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CallMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.remote.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<256>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<256>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <CallState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.state.get_or_insert_with(|| {
                    fidl::new_empty!(CallState, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    CallState,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <CallDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.direction.get_or_insert_with(|| {
                    fidl::new_empty!(CallDirection, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    CallDirection,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }
}