fidl_fuchsia_bluetooth_avrcp/

fidl_fuchsia_bluetooth_avrcp.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_avrcp__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, PartialEq)]
pub struct PeerManagerGetBrowseControllerForTargetRequest {
    pub peer_id: fidl_fuchsia_bluetooth::PeerId,
    pub client: fidl::endpoints::ServerEnd<BrowseControllerMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct PeerManagerGetControllerForTargetRequest {
    pub peer_id: fidl_fuchsia_bluetooth::PeerId,
    pub client: fidl::endpoints::ServerEnd<ControllerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PeerManagerRegisterTargetHandlerRequest {
    pub handler: fidl::endpoints::ClientEnd<TargetHandlerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PeerManagerSetAbsoluteVolumeHandlerRequest {
    pub handler: fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for AbsoluteVolumeHandlerMarker {
    type Proxy = AbsoluteVolumeHandlerProxy;
    type RequestStream = AbsoluteVolumeHandlerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AbsoluteVolumeHandlerSynchronousProxy;

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

pub trait AbsoluteVolumeHandlerProxyInterface: Send + Sync {
    type SetVolumeResponseFut: std::future::Future<Output = Result<u8, fidl::Error>> + Send;
    fn r#set_volume(&self, requested_volume: u8) -> Self::SetVolumeResponseFut;
    type OnVolumeChangedResponseFut: std::future::Future<Output = Result<u8, fidl::Error>> + Send;
    fn r#on_volume_changed(&self) -> Self::OnVolumeChangedResponseFut;
    type GetCurrentVolumeResponseFut: std::future::Future<Output = Result<u8, fidl::Error>> + Send;
    fn r#get_current_volume(&self) -> Self::GetCurrentVolumeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AbsoluteVolumeHandlerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AbsoluteVolumeHandlerSynchronousProxy {
    type Proxy = AbsoluteVolumeHandlerProxy;
    type Protocol = AbsoluteVolumeHandlerMarker;

    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 AbsoluteVolumeHandlerSynchronousProxy {
    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<AbsoluteVolumeHandlerEvent, fidl::Error> {
        AbsoluteVolumeHandlerEvent::decode(
            self.client.wait_for_event::<AbsoluteVolumeHandlerMarker>(deadline)?,
        )
    }

    /// Requests that the absolute volume of the player be changed.
    /// `requested_volume` is the requested volume by the peer.
    /// Returns the actual volume set locally by the handler.
    pub fn r#set_volume(
        &self,
        mut requested_volume: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u8, fidl::Error> {
        let _response = self.client.send_query::<
            AbsoluteVolumeHandlerSetVolumeRequest,
            AbsoluteVolumeHandlerSetVolumeResponse,
            AbsoluteVolumeHandlerMarker,
        >(
            (requested_volume,),
            0x2796843ecbdecc65,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.set_volume)
    }

    /// Returns latest volume of the handler to the AVRCP service. This function should return
    /// immediately on the first call and if the volume has changed since the last call to this
    /// function, otherwise it should only return when the volume has been changed.
    /// Multiple outstanding `OnVolumeChanged` requests can be made - all outstanding calls will
    /// return when the volume has been changed.
    pub fn r#on_volume_changed(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u8, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            AbsoluteVolumeHandlerOnVolumeChangedResponse,
            AbsoluteVolumeHandlerMarker,
        >(
            (),
            0x1a1f9cffd4f2a74,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.new_volume)
    }

    /// Returns the current volume immediately.
    pub fn r#get_current_volume(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u8, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            AbsoluteVolumeHandlerGetCurrentVolumeResponse,
            AbsoluteVolumeHandlerMarker,
        >(
            (),
            0x6ae76e0c77ac35ff,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.volume)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AbsoluteVolumeHandlerProxy {
    type Protocol = AbsoluteVolumeHandlerMarker;

    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 AbsoluteVolumeHandlerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.avrcp/AbsoluteVolumeHandler.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AbsoluteVolumeHandlerMarker 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) -> AbsoluteVolumeHandlerEventStream {
        AbsoluteVolumeHandlerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Requests that the absolute volume of the player be changed.
    /// `requested_volume` is the requested volume by the peer.
    /// Returns the actual volume set locally by the handler.
    pub fn r#set_volume(
        &self,
        mut requested_volume: u8,
    ) -> fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AbsoluteVolumeHandlerProxyInterface::r#set_volume(self, requested_volume)
    }

    /// Returns latest volume of the handler to the AVRCP service. This function should return
    /// immediately on the first call and if the volume has changed since the last call to this
    /// function, otherwise it should only return when the volume has been changed.
    /// Multiple outstanding `OnVolumeChanged` requests can be made - all outstanding calls will
    /// return when the volume has been changed.
    pub fn r#on_volume_changed(
        &self,
    ) -> fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AbsoluteVolumeHandlerProxyInterface::r#on_volume_changed(self)
    }

    /// Returns the current volume immediately.
    pub fn r#get_current_volume(
        &self,
    ) -> fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AbsoluteVolumeHandlerProxyInterface::r#get_current_volume(self)
    }
}

impl AbsoluteVolumeHandlerProxyInterface for AbsoluteVolumeHandlerProxy {
    type SetVolumeResponseFut =
        fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_volume(&self, mut requested_volume: u8) -> Self::SetVolumeResponseFut {
        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::<
                AbsoluteVolumeHandlerSetVolumeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2796843ecbdecc65,
            >(_buf?)?;
            Ok(_response.set_volume)
        }
        self.client.send_query_and_decode::<AbsoluteVolumeHandlerSetVolumeRequest, u8>(
            (requested_volume,),
            0x2796843ecbdecc65,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type OnVolumeChangedResponseFut =
        fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_volume_changed(&self) -> Self::OnVolumeChangedResponseFut {
        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::<
                AbsoluteVolumeHandlerOnVolumeChangedResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1a1f9cffd4f2a74,
            >(_buf?)?;
            Ok(_response.new_volume)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u8>(
            (),
            0x1a1f9cffd4f2a74,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCurrentVolumeResponseFut =
        fidl::client::QueryResponseFut<u8, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_current_volume(&self) -> Self::GetCurrentVolumeResponseFut {
        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::<
                AbsoluteVolumeHandlerGetCurrentVolumeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ae76e0c77ac35ff,
            >(_buf?)?;
            Ok(_response.volume)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u8>(
            (),
            0x6ae76e0c77ac35ff,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for AbsoluteVolumeHandlerEventStream {
    type Item = Result<AbsoluteVolumeHandlerEvent, 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(AbsoluteVolumeHandlerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl AbsoluteVolumeHandlerEvent {
    /// Decodes a message buffer as a [`AbsoluteVolumeHandlerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<AbsoluteVolumeHandlerEvent, 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:
                    <AbsoluteVolumeHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for AbsoluteVolumeHandlerRequestStream {
    type Protocol = AbsoluteVolumeHandlerMarker;
    type ControlHandle = AbsoluteVolumeHandlerControlHandle;

    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 {
        AbsoluteVolumeHandlerControlHandle { 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 AbsoluteVolumeHandlerRequestStream {
    type Item = Result<AbsoluteVolumeHandlerRequest, 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 AbsoluteVolumeHandlerRequestStream 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 {
                0x2796843ecbdecc65 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AbsoluteVolumeHandlerSetVolumeRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AbsoluteVolumeHandlerSetVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AbsoluteVolumeHandlerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AbsoluteVolumeHandlerRequest::SetVolume {requested_volume: req.requested_volume,

                        responder: AbsoluteVolumeHandlerSetVolumeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1a1f9cffd4f2a74 => {
                    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 = AbsoluteVolumeHandlerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AbsoluteVolumeHandlerRequest::OnVolumeChanged {
                        responder: AbsoluteVolumeHandlerOnVolumeChangedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6ae76e0c77ac35ff => {
                    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 = AbsoluteVolumeHandlerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AbsoluteVolumeHandlerRequest::GetCurrentVolume {
                        responder: AbsoluteVolumeHandlerGetCurrentVolumeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <AbsoluteVolumeHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Handler for absolute volume requests from a remote peer. See AVRCP v 1.6.2 section 6.13.2.
/// Absolute volume is represented as a percentage using one byte with the most significant bit
/// reserved. 0% is represented as 0x0 and 100% as 0x7f. Volume should scaled between the
/// two values.
#[derive(Debug)]
pub enum AbsoluteVolumeHandlerRequest {
    /// Requests that the absolute volume of the player be changed.
    /// `requested_volume` is the requested volume by the peer.
    /// Returns the actual volume set locally by the handler.
    SetVolume { requested_volume: u8, responder: AbsoluteVolumeHandlerSetVolumeResponder },
    /// Returns latest volume of the handler to the AVRCP service. This function should return
    /// immediately on the first call and if the volume has changed since the last call to this
    /// function, otherwise it should only return when the volume has been changed.
    /// Multiple outstanding `OnVolumeChanged` requests can be made - all outstanding calls will
    /// return when the volume has been changed.
    OnVolumeChanged { responder: AbsoluteVolumeHandlerOnVolumeChangedResponder },
    /// Returns the current volume immediately.
    GetCurrentVolume { responder: AbsoluteVolumeHandlerGetCurrentVolumeResponder },
}

impl AbsoluteVolumeHandlerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_volume(self) -> Option<(u8, AbsoluteVolumeHandlerSetVolumeResponder)> {
        if let AbsoluteVolumeHandlerRequest::SetVolume { requested_volume, responder } = self {
            Some((requested_volume, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_volume_changed(self) -> Option<(AbsoluteVolumeHandlerOnVolumeChangedResponder)> {
        if let AbsoluteVolumeHandlerRequest::OnVolumeChanged { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_current_volume(
        self,
    ) -> Option<(AbsoluteVolumeHandlerGetCurrentVolumeResponder)> {
        if let AbsoluteVolumeHandlerRequest::GetCurrentVolume { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AbsoluteVolumeHandlerRequest::SetVolume { .. } => "set_volume",
            AbsoluteVolumeHandlerRequest::OnVolumeChanged { .. } => "on_volume_changed",
            AbsoluteVolumeHandlerRequest::GetCurrentVolume { .. } => "get_current_volume",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AbsoluteVolumeHandlerControlHandle {
    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 AbsoluteVolumeHandlerControlHandle {}

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

/// Set the the channel to be shutdown (see [`AbsoluteVolumeHandlerControlHandle::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 AbsoluteVolumeHandlerSetVolumeResponder {
    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 AbsoluteVolumeHandlerSetVolumeResponder {
    type ControlHandle = AbsoluteVolumeHandlerControlHandle;

    fn control_handle(&self) -> &AbsoluteVolumeHandlerControlHandle {
        &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 AbsoluteVolumeHandlerSetVolumeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut set_volume: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(set_volume);
        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 set_volume: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(set_volume);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`AbsoluteVolumeHandlerControlHandle::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 AbsoluteVolumeHandlerOnVolumeChangedResponder {
    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 AbsoluteVolumeHandlerOnVolumeChangedResponder {
    type ControlHandle = AbsoluteVolumeHandlerControlHandle;

    fn control_handle(&self) -> &AbsoluteVolumeHandlerControlHandle {
        &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 AbsoluteVolumeHandlerOnVolumeChangedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut new_volume: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(new_volume);
        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 new_volume: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(new_volume);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`AbsoluteVolumeHandlerControlHandle::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 AbsoluteVolumeHandlerGetCurrentVolumeResponder {
    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 AbsoluteVolumeHandlerGetCurrentVolumeResponder {
    type ControlHandle = AbsoluteVolumeHandlerControlHandle;

    fn control_handle(&self) -> &AbsoluteVolumeHandlerControlHandle {
        &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 AbsoluteVolumeHandlerGetCurrentVolumeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut volume: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(volume);
        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 volume: u8) -> Result<(), fidl::Error> {
        let _result = self.send_raw(volume);
        self.drop_without_shutdown();
        _result
    }

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

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

impl fidl::endpoints::ProtocolMarker for BrowseControllerMarker {
    type Proxy = BrowseControllerProxy;
    type RequestStream = BrowseControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BrowseControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) BrowseController";
}
pub type BrowseControllerGetMediaPlayerItemsResult =
    Result<Vec<MediaPlayerItem>, BrowseControllerError>;
pub type BrowseControllerGetNowPlayingItemsResult =
    Result<Vec<MediaElementItem>, BrowseControllerError>;
pub type BrowseControllerGetFileSystemItemsResult =
    Result<Vec<FileSystemItem>, BrowseControllerError>;
pub type BrowseControllerChangePathResult = Result<u32, BrowseControllerError>;
pub type BrowseControllerPlayFileSystemItemResult = Result<(), BrowseControllerError>;
pub type BrowseControllerPlayNowPlayingItemResult = Result<(), BrowseControllerError>;
pub type BrowseControllerSetBrowsedPlayerResult = Result<(), BrowseControllerError>;

pub trait BrowseControllerProxyInterface: Send + Sync {
    type GetMediaPlayerItemsResponseFut: std::future::Future<Output = Result<BrowseControllerGetMediaPlayerItemsResult, fidl::Error>>
        + Send;
    fn r#get_media_player_items(
        &self,
        start_index: u32,
        end_index: u32,
    ) -> Self::GetMediaPlayerItemsResponseFut;
    type GetNowPlayingItemsResponseFut: std::future::Future<Output = Result<BrowseControllerGetNowPlayingItemsResult, fidl::Error>>
        + Send;
    fn r#get_now_playing_items(
        &self,
        start_index: u32,
        end_index: u32,
        attribute_option: &AttributeRequestOption,
    ) -> Self::GetNowPlayingItemsResponseFut;
    type GetFileSystemItemsResponseFut: std::future::Future<Output = Result<BrowseControllerGetFileSystemItemsResult, fidl::Error>>
        + Send;
    fn r#get_file_system_items(
        &self,
        start_index: u32,
        end_index: u32,
        attribute_option: &AttributeRequestOption,
    ) -> Self::GetFileSystemItemsResponseFut;
    type ChangePathResponseFut: std::future::Future<Output = Result<BrowseControllerChangePathResult, fidl::Error>>
        + Send;
    fn r#change_path(&self, path: &Path) -> Self::ChangePathResponseFut;
    type PlayFileSystemItemResponseFut: std::future::Future<Output = Result<BrowseControllerPlayFileSystemItemResult, fidl::Error>>
        + Send;
    fn r#play_file_system_item(&self, uid: u64) -> Self::PlayFileSystemItemResponseFut;
    type PlayNowPlayingItemResponseFut: std::future::Future<Output = Result<BrowseControllerPlayNowPlayingItemResult, fidl::Error>>
        + Send;
    fn r#play_now_playing_item(&self, uid: u64) -> Self::PlayNowPlayingItemResponseFut;
    type SetBrowsedPlayerResponseFut: std::future::Future<Output = Result<BrowseControllerSetBrowsedPlayerResult, fidl::Error>>
        + Send;
    fn r#set_browsed_player(&self, player_id: u16) -> Self::SetBrowsedPlayerResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BrowseControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BrowseControllerSynchronousProxy {
    type Proxy = BrowseControllerProxy;
    type Protocol = BrowseControllerMarker;

    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 BrowseControllerSynchronousProxy {
    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<BrowseControllerEvent, fidl::Error> {
        BrowseControllerEvent::decode(
            self.client.wait_for_event::<BrowseControllerMarker>(deadline)?,
        )
    }

    /// Used for GetFolderItems(MediaPlayerList).
    /// Gets the list of media players. End index is inclusive.
    pub fn r#get_media_player_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerGetMediaPlayerItemsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<BrowseControllerGetMediaPlayerItemsRequest, fidl::encoding::ResultType<
                BrowseControllerGetMediaPlayerItemsResponse,
                BrowseControllerError,
            >, BrowseControllerMarker>(
                (start_index, end_index),
                0x49c06d30a9aa02ba,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.items))
    }

    /// Used for GetFolderItems(NowPlayingList).
    /// Gets the list of items from the now playing list aka the queue of the
    /// addressed media player.
    /// + request `end_index` is inclusive.
    pub fn r#get_now_playing_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        mut attribute_option: &AttributeRequestOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerGetNowPlayingItemsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<BrowseControllerGetNowPlayingItemsRequest, fidl::encoding::ResultType<
                BrowseControllerGetNowPlayingItemsResponse,
                BrowseControllerError,
            >, BrowseControllerMarker>(
                (start_index, end_index, attribute_option),
                0x35f5a88695b46cf7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.items))
    }

    /// Used for GetFolderItems(MediaPlayerVirtualFilesystem).
    /// Gets the list of folder item/media element item.
    /// + request `end_index` is inclusive.
    pub fn r#get_file_system_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        mut attribute_option: &AttributeRequestOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerGetFileSystemItemsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<BrowseControllerGetFileSystemItemsRequest, fidl::encoding::ResultType<
                BrowseControllerGetFileSystemItemsResponse,
                BrowseControllerError,
            >, BrowseControllerMarker>(
                (start_index, end_index, attribute_option),
                0x5d1415aecee72133,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.items))
    }

    /// Used for ChangePath browse command.
    /// + request `path` dictates whether or not the direction will be Move Up
    ///   or Move down. If `path.parent` is set, direction will be Move Up. If
    ///   `path.child_folder_uid` is set, direction will be Move Down.
    pub fn r#change_path(
        &self,
        mut path: &Path,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerChangePathResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BrowseControllerChangePathRequest, fidl::encoding::ResultType<
                    BrowseControllerChangePathResponse,
                    BrowseControllerError,
                >, BrowseControllerMarker>(
                    (path,),
                    0x2e0600579d43b51e,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x.num_items))
    }

    ///  Used for PlayItem(FileSystem).
    pub fn r#play_file_system_item(
        &self,
        mut uid: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerPlayFileSystemItemResult, fidl::Error> {
        let _response = self.client.send_query::<
            BrowseControllerPlayFileSystemItemRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BrowseControllerError>,
            BrowseControllerMarker,
        >(
            (uid,),
            0x57075115ce25cf16,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    ///  Used for PlayItem(NowPlayingList). Plays the specified item from the now playing
    /// list aka the queue of the addressed media player.
    pub fn r#play_now_playing_item(
        &self,
        mut uid: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerPlayNowPlayingItemResult, fidl::Error> {
        let _response = self.client.send_query::<
            BrowseControllerPlayNowPlayingItemRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BrowseControllerError>,
            BrowseControllerMarker,
        >(
            (uid,),
            0x116e151d547fd2d7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Changes the addressed `player_id` on the target when multiple are supported.
    pub fn r#set_browsed_player(
        &self,
        mut player_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BrowseControllerSetBrowsedPlayerResult, fidl::Error> {
        let _response = self.client.send_query::<
            BrowseControllerSetBrowsedPlayerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BrowseControllerError>,
            BrowseControllerMarker,
        >(
            (player_id,),
            0x3e3256f57f8848da,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BrowseControllerProxy {
    type Protocol = BrowseControllerMarker;

    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 BrowseControllerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.avrcp/BrowseController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BrowseControllerMarker 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) -> BrowseControllerEventStream {
        BrowseControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Used for GetFolderItems(MediaPlayerList).
    /// Gets the list of media players. End index is inclusive.
    pub fn r#get_media_player_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerGetMediaPlayerItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#get_media_player_items(self, start_index, end_index)
    }

    /// Used for GetFolderItems(NowPlayingList).
    /// Gets the list of items from the now playing list aka the queue of the
    /// addressed media player.
    /// + request `end_index` is inclusive.
    pub fn r#get_now_playing_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        mut attribute_option: &AttributeRequestOption,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerGetNowPlayingItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#get_now_playing_items(
            self,
            start_index,
            end_index,
            attribute_option,
        )
    }

    /// Used for GetFolderItems(MediaPlayerVirtualFilesystem).
    /// Gets the list of folder item/media element item.
    /// + request `end_index` is inclusive.
    pub fn r#get_file_system_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        mut attribute_option: &AttributeRequestOption,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerGetFileSystemItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#get_file_system_items(
            self,
            start_index,
            end_index,
            attribute_option,
        )
    }

    /// Used for ChangePath browse command.
    /// + request `path` dictates whether or not the direction will be Move Up
    ///   or Move down. If `path.parent` is set, direction will be Move Up. If
    ///   `path.child_folder_uid` is set, direction will be Move Down.
    pub fn r#change_path(
        &self,
        mut path: &Path,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerChangePathResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#change_path(self, path)
    }

    ///  Used for PlayItem(FileSystem).
    pub fn r#play_file_system_item(
        &self,
        mut uid: u64,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerPlayFileSystemItemResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#play_file_system_item(self, uid)
    }

    ///  Used for PlayItem(NowPlayingList). Plays the specified item from the now playing
    /// list aka the queue of the addressed media player.
    pub fn r#play_now_playing_item(
        &self,
        mut uid: u64,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerPlayNowPlayingItemResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#play_now_playing_item(self, uid)
    }

    /// Changes the addressed `player_id` on the target when multiple are supported.
    pub fn r#set_browsed_player(
        &self,
        mut player_id: u16,
    ) -> fidl::client::QueryResponseFut<
        BrowseControllerSetBrowsedPlayerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BrowseControllerProxyInterface::r#set_browsed_player(self, player_id)
    }
}

impl BrowseControllerProxyInterface for BrowseControllerProxy {
    type GetMediaPlayerItemsResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerGetMediaPlayerItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_media_player_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
    ) -> Self::GetMediaPlayerItemsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerGetMediaPlayerItemsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BrowseControllerGetMediaPlayerItemsResponse,
                    BrowseControllerError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49c06d30a9aa02ba,
            >(_buf?)?;
            Ok(_response.map(|x| x.items))
        }
        self.client.send_query_and_decode::<
            BrowseControllerGetMediaPlayerItemsRequest,
            BrowseControllerGetMediaPlayerItemsResult,
        >(
            (start_index, end_index,),
            0x49c06d30a9aa02ba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetNowPlayingItemsResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerGetNowPlayingItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_now_playing_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        mut attribute_option: &AttributeRequestOption,
    ) -> Self::GetNowPlayingItemsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerGetNowPlayingItemsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BrowseControllerGetNowPlayingItemsResponse,
                    BrowseControllerError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x35f5a88695b46cf7,
            >(_buf?)?;
            Ok(_response.map(|x| x.items))
        }
        self.client.send_query_and_decode::<
            BrowseControllerGetNowPlayingItemsRequest,
            BrowseControllerGetNowPlayingItemsResult,
        >(
            (start_index, end_index, attribute_option,),
            0x35f5a88695b46cf7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFileSystemItemsResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerGetFileSystemItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_file_system_items(
        &self,
        mut start_index: u32,
        mut end_index: u32,
        mut attribute_option: &AttributeRequestOption,
    ) -> Self::GetFileSystemItemsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerGetFileSystemItemsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BrowseControllerGetFileSystemItemsResponse,
                    BrowseControllerError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5d1415aecee72133,
            >(_buf?)?;
            Ok(_response.map(|x| x.items))
        }
        self.client.send_query_and_decode::<
            BrowseControllerGetFileSystemItemsRequest,
            BrowseControllerGetFileSystemItemsResult,
        >(
            (start_index, end_index, attribute_option,),
            0x5d1415aecee72133,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ChangePathResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerChangePathResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#change_path(&self, mut path: &Path) -> Self::ChangePathResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerChangePathResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BrowseControllerChangePathResponse,
                    BrowseControllerError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e0600579d43b51e,
            >(_buf?)?;
            Ok(_response.map(|x| x.num_items))
        }
        self.client.send_query_and_decode::<
            BrowseControllerChangePathRequest,
            BrowseControllerChangePathResult,
        >(
            (path,),
            0x2e0600579d43b51e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type PlayFileSystemItemResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerPlayFileSystemItemResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#play_file_system_item(&self, mut uid: u64) -> Self::PlayFileSystemItemResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerPlayFileSystemItemResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BrowseControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57075115ce25cf16,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BrowseControllerPlayFileSystemItemRequest,
            BrowseControllerPlayFileSystemItemResult,
        >(
            (uid,),
            0x57075115ce25cf16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type PlayNowPlayingItemResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerPlayNowPlayingItemResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#play_now_playing_item(&self, mut uid: u64) -> Self::PlayNowPlayingItemResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerPlayNowPlayingItemResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BrowseControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x116e151d547fd2d7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BrowseControllerPlayNowPlayingItemRequest,
            BrowseControllerPlayNowPlayingItemResult,
        >(
            (uid,),
            0x116e151d547fd2d7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBrowsedPlayerResponseFut = fidl::client::QueryResponseFut<
        BrowseControllerSetBrowsedPlayerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_browsed_player(&self, mut player_id: u16) -> Self::SetBrowsedPlayerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BrowseControllerSetBrowsedPlayerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BrowseControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3e3256f57f8848da,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BrowseControllerSetBrowsedPlayerRequest,
            BrowseControllerSetBrowsedPlayerResult,
        >(
            (player_id,),
            0x3e3256f57f8848da,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for BrowseControllerEventStream {
    type Item = Result<BrowseControllerEvent, 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(BrowseControllerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl BrowseControllerEvent {
    /// Decodes a message buffer as a [`BrowseControllerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BrowseControllerEvent, 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:
                    <BrowseControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for BrowseControllerRequestStream {
    type Protocol = BrowseControllerMarker;
    type ControlHandle = BrowseControllerControlHandle;

    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 {
        BrowseControllerControlHandle { 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 BrowseControllerRequestStream {
    type Item = Result<BrowseControllerRequest, 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 BrowseControllerRequestStream 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 {
                    0x49c06d30a9aa02ba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerGetMediaPlayerItemsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerGetMediaPlayerItemsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::GetMediaPlayerItems {
                            start_index: req.start_index,
                            end_index: req.end_index,

                            responder: BrowseControllerGetMediaPlayerItemsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35f5a88695b46cf7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerGetNowPlayingItemsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerGetNowPlayingItemsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::GetNowPlayingItems {
                            start_index: req.start_index,
                            end_index: req.end_index,
                            attribute_option: req.attribute_option,

                            responder: BrowseControllerGetNowPlayingItemsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5d1415aecee72133 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerGetFileSystemItemsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerGetFileSystemItemsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::GetFileSystemItems {
                            start_index: req.start_index,
                            end_index: req.end_index,
                            attribute_option: req.attribute_option,

                            responder: BrowseControllerGetFileSystemItemsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2e0600579d43b51e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerChangePathRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerChangePathRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::ChangePath {
                            path: req.path,

                            responder: BrowseControllerChangePathResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57075115ce25cf16 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerPlayFileSystemItemRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerPlayFileSystemItemRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::PlayFileSystemItem {
                            uid: req.uid,

                            responder: BrowseControllerPlayFileSystemItemResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x116e151d547fd2d7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerPlayNowPlayingItemRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerPlayNowPlayingItemRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::PlayNowPlayingItem {
                            uid: req.uid,

                            responder: BrowseControllerPlayNowPlayingItemResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3e3256f57f8848da => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BrowseControllerSetBrowsedPlayerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BrowseControllerSetBrowsedPlayerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BrowseControllerControlHandle { inner: this.inner.clone() };
                        Ok(BrowseControllerRequest::SetBrowsedPlayer {
                            player_id: req.player_id,

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

/// Client wrapper for local controller (CT) -> remote target (TG) AVCTP
/// connections between devices for browse related commands.
///
/// NOTE: a client is high level construct and does not represent a connection
/// with a device. Connections are internally managed and may be shared by
/// multiple clients. The actual connection may be opened on-demand after any
/// command here is called.
#[derive(Debug)]
pub enum BrowseControllerRequest {
    /// Used for GetFolderItems(MediaPlayerList).
    /// Gets the list of media players. End index is inclusive.
    GetMediaPlayerItems {
        start_index: u32,
        end_index: u32,
        responder: BrowseControllerGetMediaPlayerItemsResponder,
    },
    /// Used for GetFolderItems(NowPlayingList).
    /// Gets the list of items from the now playing list aka the queue of the
    /// addressed media player.
    /// + request `end_index` is inclusive.
    GetNowPlayingItems {
        start_index: u32,
        end_index: u32,
        attribute_option: AttributeRequestOption,
        responder: BrowseControllerGetNowPlayingItemsResponder,
    },
    /// Used for GetFolderItems(MediaPlayerVirtualFilesystem).
    /// Gets the list of folder item/media element item.
    /// + request `end_index` is inclusive.
    GetFileSystemItems {
        start_index: u32,
        end_index: u32,
        attribute_option: AttributeRequestOption,
        responder: BrowseControllerGetFileSystemItemsResponder,
    },
    /// Used for ChangePath browse command.
    /// + request `path` dictates whether or not the direction will be Move Up
    ///   or Move down. If `path.parent` is set, direction will be Move Up. If
    ///   `path.child_folder_uid` is set, direction will be Move Down.
    ChangePath { path: Path, responder: BrowseControllerChangePathResponder },
    ///  Used for PlayItem(FileSystem).
    PlayFileSystemItem { uid: u64, responder: BrowseControllerPlayFileSystemItemResponder },
    ///  Used for PlayItem(NowPlayingList). Plays the specified item from the now playing
    /// list aka the queue of the addressed media player.
    PlayNowPlayingItem { uid: u64, responder: BrowseControllerPlayNowPlayingItemResponder },
    /// Changes the addressed `player_id` on the target when multiple are supported.
    SetBrowsedPlayer { player_id: u16, responder: BrowseControllerSetBrowsedPlayerResponder },
}

impl BrowseControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_media_player_items(
        self,
    ) -> Option<(u32, u32, BrowseControllerGetMediaPlayerItemsResponder)> {
        if let BrowseControllerRequest::GetMediaPlayerItems { start_index, end_index, responder } =
            self
        {
            Some((start_index, end_index, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_now_playing_items(
        self,
    ) -> Option<(u32, u32, AttributeRequestOption, BrowseControllerGetNowPlayingItemsResponder)>
    {
        if let BrowseControllerRequest::GetNowPlayingItems {
            start_index,
            end_index,
            attribute_option,
            responder,
        } = self
        {
            Some((start_index, end_index, attribute_option, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_file_system_items(
        self,
    ) -> Option<(u32, u32, AttributeRequestOption, BrowseControllerGetFileSystemItemsResponder)>
    {
        if let BrowseControllerRequest::GetFileSystemItems {
            start_index,
            end_index,
            attribute_option,
            responder,
        } = self
        {
            Some((start_index, end_index, attribute_option, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_change_path(self) -> Option<(Path, BrowseControllerChangePathResponder)> {
        if let BrowseControllerRequest::ChangePath { path, responder } = self {
            Some((path, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_play_file_system_item(
        self,
    ) -> Option<(u64, BrowseControllerPlayFileSystemItemResponder)> {
        if let BrowseControllerRequest::PlayFileSystemItem { uid, responder } = self {
            Some((uid, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_play_now_playing_item(
        self,
    ) -> Option<(u64, BrowseControllerPlayNowPlayingItemResponder)> {
        if let BrowseControllerRequest::PlayNowPlayingItem { uid, responder } = self {
            Some((uid, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_browsed_player(
        self,
    ) -> Option<(u16, BrowseControllerSetBrowsedPlayerResponder)> {
        if let BrowseControllerRequest::SetBrowsedPlayer { player_id, responder } = self {
            Some((player_id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BrowseControllerRequest::GetMediaPlayerItems { .. } => "get_media_player_items",
            BrowseControllerRequest::GetNowPlayingItems { .. } => "get_now_playing_items",
            BrowseControllerRequest::GetFileSystemItems { .. } => "get_file_system_items",
            BrowseControllerRequest::ChangePath { .. } => "change_path",
            BrowseControllerRequest::PlayFileSystemItem { .. } => "play_file_system_item",
            BrowseControllerRequest::PlayNowPlayingItem { .. } => "play_now_playing_item",
            BrowseControllerRequest::SetBrowsedPlayer { .. } => "set_browsed_player",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for BrowseControllerControlHandle {
    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 BrowseControllerControlHandle {}

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerGetMediaPlayerItemsResponder {
    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 BrowseControllerGetMediaPlayerItemsResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerGetMediaPlayerItemsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&[MediaPlayerItem], BrowseControllerError>,
    ) -> 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<&[MediaPlayerItem], BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&[MediaPlayerItem], BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BrowseControllerGetMediaPlayerItemsResponse,
            BrowseControllerError,
        >>(
            result.map(|items| (items,)),
            self.tx_id,
            0x49c06d30a9aa02ba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerGetNowPlayingItemsResponder {
    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 BrowseControllerGetNowPlayingItemsResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerGetNowPlayingItemsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&[MediaElementItem], BrowseControllerError>,
    ) -> 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<&[MediaElementItem], BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&[MediaElementItem], BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BrowseControllerGetNowPlayingItemsResponse,
            BrowseControllerError,
        >>(
            result.map(|items| (items,)),
            self.tx_id,
            0x35f5a88695b46cf7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerGetFileSystemItemsResponder {
    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 BrowseControllerGetFileSystemItemsResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerGetFileSystemItemsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&[FileSystemItem], BrowseControllerError>,
    ) -> 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<&[FileSystemItem], BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&[FileSystemItem], BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BrowseControllerGetFileSystemItemsResponse,
            BrowseControllerError,
        >>(
            result.map(|items| (items,)),
            self.tx_id,
            0x5d1415aecee72133,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerChangePathResponder {
    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 BrowseControllerChangePathResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerChangePathResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u32, BrowseControllerError>) -> 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<u32, BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u32, BrowseControllerError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BrowseControllerChangePathResponse,
            BrowseControllerError,
        >>(
            result.map(|num_items| (num_items,)),
            self.tx_id,
            0x2e0600579d43b51e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerPlayFileSystemItemResponder {
    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 BrowseControllerPlayFileSystemItemResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerPlayFileSystemItemResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), BrowseControllerError>) -> 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<(), BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerPlayNowPlayingItemResponder {
    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 BrowseControllerPlayNowPlayingItemResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerPlayNowPlayingItemResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), BrowseControllerError>) -> 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<(), BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`BrowseControllerControlHandle::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 BrowseControllerSetBrowsedPlayerResponder {
    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 BrowseControllerSetBrowsedPlayerResponder {
    type ControlHandle = BrowseControllerControlHandle;

    fn control_handle(&self) -> &BrowseControllerControlHandle {
        &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 BrowseControllerSetBrowsedPlayerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), BrowseControllerError>) -> 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<(), BrowseControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

impl fidl::endpoints::ProtocolMarker for ControllerMarker {
    type Proxy = ControllerProxy;
    type RequestStream = ControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Controller";
}
pub type ControllerGetPlayerApplicationSettingsResult =
    Result<PlayerApplicationSettings, ControllerError>;
pub type ControllerSetPlayerApplicationSettingsResult =
    Result<PlayerApplicationSettings, ControllerError>;
pub type ControllerGetMediaAttributesResult = Result<MediaAttributes, ControllerError>;
pub type ControllerGetPlayStatusResult = Result<PlayStatus, ControllerError>;
pub type ControllerSetAbsoluteVolumeResult = Result<u8, ControllerError>;
pub type ControllerInformBatteryStatusResult = Result<(), ControllerError>;
pub type ControllerSetAddressedPlayerResult = Result<(), ControllerError>;
pub type ControllerSendCommandResult = Result<(), ControllerError>;

pub trait ControllerProxyInterface: Send + Sync {
    type GetPlayerApplicationSettingsResponseFut: std::future::Future<
            Output = Result<ControllerGetPlayerApplicationSettingsResult, fidl::Error>,
        > + Send;
    fn r#get_player_application_settings(
        &self,
        attribute_ids: &[PlayerApplicationSettingAttributeId],
    ) -> Self::GetPlayerApplicationSettingsResponseFut;
    type SetPlayerApplicationSettingsResponseFut: std::future::Future<
            Output = Result<ControllerSetPlayerApplicationSettingsResult, fidl::Error>,
        > + Send;
    fn r#set_player_application_settings(
        &self,
        requested_settings: &PlayerApplicationSettings,
    ) -> Self::SetPlayerApplicationSettingsResponseFut;
    type GetMediaAttributesResponseFut: std::future::Future<Output = Result<ControllerGetMediaAttributesResult, fidl::Error>>
        + Send;
    fn r#get_media_attributes(&self) -> Self::GetMediaAttributesResponseFut;
    type GetPlayStatusResponseFut: std::future::Future<Output = Result<ControllerGetPlayStatusResult, fidl::Error>>
        + Send;
    fn r#get_play_status(&self) -> Self::GetPlayStatusResponseFut;
    type SetAbsoluteVolumeResponseFut: std::future::Future<Output = Result<ControllerSetAbsoluteVolumeResult, fidl::Error>>
        + Send;
    fn r#set_absolute_volume(&self, requested_volume: u8) -> Self::SetAbsoluteVolumeResponseFut;
    type InformBatteryStatusResponseFut: std::future::Future<Output = Result<ControllerInformBatteryStatusResult, fidl::Error>>
        + Send;
    fn r#inform_battery_status(
        &self,
        battery_status: BatteryStatus,
    ) -> Self::InformBatteryStatusResponseFut;
    fn r#set_notification_filter(
        &self,
        notifications: Notifications,
        position_change_interval: u32,
    ) -> Result<(), fidl::Error>;
    fn r#notify_notification_handled(&self) -> Result<(), fidl::Error>;
    type SetAddressedPlayerResponseFut: std::future::Future<Output = Result<ControllerSetAddressedPlayerResult, fidl::Error>>
        + Send;
    fn r#set_addressed_player(&self, player_id: u16) -> Self::SetAddressedPlayerResponseFut;
    type SendCommandResponseFut: std::future::Future<Output = Result<ControllerSendCommandResult, fidl::Error>>
        + Send;
    fn r#send_command(&self, command: AvcPanelCommand) -> Self::SendCommandResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
    type Proxy = ControllerProxy;
    type Protocol = ControllerMarker;

    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 ControllerSynchronousProxy {
    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<ControllerEvent, fidl::Error> {
        ControllerEvent::decode(self.client.wait_for_event::<ControllerMarker>(deadline)?)
    }

    /// Returns currently set player application setting values for the `attribute_ids`.
    /// If no `attribute_ids` are provided, this method will query the TG for all valid
    /// attribute ID's, and return the currently set player application setting values.
    pub fn r#get_player_application_settings(
        &self,
        mut attribute_ids: &[PlayerApplicationSettingAttributeId],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerGetPlayerApplicationSettingsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<ControllerGetPlayerApplicationSettingsRequest, fidl::encoding::ResultType<
                ControllerGetPlayerApplicationSettingsResponse,
                ControllerError,
            >, ControllerMarker>(
                (attribute_ids,),
                0x681de2da50670120,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.current_settings))
    }

    /// Sets the player application settings specified by `requested_settings`. Only
    /// settings specified in the input `requested_settings` will be overwritten.
    /// Returns the actual settings that were set.
    /// Settings provided in the `requested_settings` that are unsupported or unknown
    /// will not be set; the returned `set_settings` will include only the settings
    /// that were successfully set on the remote target.
    pub fn r#set_player_application_settings(
        &self,
        mut requested_settings: &PlayerApplicationSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerSetPlayerApplicationSettingsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<ControllerSetPlayerApplicationSettingsRequest, fidl::encoding::ResultType<
                ControllerSetPlayerApplicationSettingsResponse,
                ControllerError,
            >, ControllerMarker>(
                (requested_settings,),
                0x6a7c9689ea3a589a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.set_settings))
    }

    /// Returns the currently playing media attributes.
    /// May send either the GetElementAttributes or GetItemAttributes command depending on what
    /// is supported.
    pub fn r#get_media_attributes(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerGetMediaAttributesResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                ControllerGetMediaAttributesResponse,
                ControllerError,
            >, ControllerMarker>(
                (),
                0x18bd14308ee3173d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.attributes))
    }

    /// Returns the status of the currently playing media.
    pub fn r#get_play_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerGetPlayStatusResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                ControllerGetPlayStatusResponse,
                ControllerError,
            >, ControllerMarker>(
                (),
                0x120735bec709fc6d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.play_status))
    }

    /// Request the absolute volume on the peer be changed. Returns the actual volume set by the
    /// peer. Values can range from 0x00 to 0x7F (with 100% volume being 0x7F). You may not get a
    /// volume changed notification event from the remote peer as result of changing this.
    pub fn r#set_absolute_volume(
        &self,
        mut requested_volume: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerSetAbsoluteVolumeResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerSetAbsoluteVolumeRequest,
            fidl::encoding::ResultType<ControllerSetAbsoluteVolumeResponse, ControllerError>,
            ControllerMarker,
        >(
            (requested_volume,),
            0x1b8d010e11d05957,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.set_volume))
    }

    /// Inform target of the controller's battery level.
    pub fn r#inform_battery_status(
        &self,
        mut battery_status: BatteryStatus,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerInformBatteryStatusResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerInformBatteryStatusRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ControllerError>,
            ControllerMarker,
        >(
            (battery_status,),
            0x11d54fbe9d12c44d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Filters notifications that will be received with [`OnNotification`]. Not all notifications
    /// are supported by all peers. Resetting the notification filter may trigger all requested
    /// notification types to post their current value to [`OnNotification`] immediately.
    ///
    /// The `position_change_interval` argument is used to set the interval in seconds that the
    /// controller client would like to be notified of `TRACK_POS_CHANGED` events.
    /// `position_change_interval` is ignored if `TRACK_POS` is not set. The position change interval
    /// is best effort and not a guarantee and events may arrive more frequently or less frequently
    /// than requested.
    pub fn r#set_notification_filter(
        &self,
        mut notifications: Notifications,
        mut position_change_interval: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ControllerSetNotificationFilterRequest>(
            (notifications, position_change_interval),
            0x4d8a327745ccd73b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Call to acknowledge handling of a notification from [`OnNotification`].
    pub fn r#notify_notification_handled(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x43d3e556557f3bc2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes the addressed `player_id` on the target when multiple are supported.
    pub fn r#set_addressed_player(
        &self,
        mut player_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerSetAddressedPlayerResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerSetAddressedPlayerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ControllerError>,
            ControllerMarker,
        >(
            (player_id,),
            0x7ffc261f10ee1da5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Send an AV\C passthrough key command. Sends both a key down and key up event.
    pub fn r#send_command(
        &self,
        mut command: AvcPanelCommand,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerSendCommandResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerSendCommandRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ControllerError>,
            ControllerMarker,
        >(
            (command,),
            0x241324c56b5bc257,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ControllerProxy {
    type Protocol = ControllerMarker;

    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 ControllerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.avrcp/Controller.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ControllerMarker 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) -> ControllerEventStream {
        ControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns currently set player application setting values for the `attribute_ids`.
    /// If no `attribute_ids` are provided, this method will query the TG for all valid
    /// attribute ID's, and return the currently set player application setting values.
    pub fn r#get_player_application_settings(
        &self,
        mut attribute_ids: &[PlayerApplicationSettingAttributeId],
    ) -> fidl::client::QueryResponseFut<
        ControllerGetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#get_player_application_settings(self, attribute_ids)
    }

    /// Sets the player application settings specified by `requested_settings`. Only
    /// settings specified in the input `requested_settings` will be overwritten.
    /// Returns the actual settings that were set.
    /// Settings provided in the `requested_settings` that are unsupported or unknown
    /// will not be set; the returned `set_settings` will include only the settings
    /// that were successfully set on the remote target.
    pub fn r#set_player_application_settings(
        &self,
        mut requested_settings: &PlayerApplicationSettings,
    ) -> fidl::client::QueryResponseFut<
        ControllerSetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#set_player_application_settings(self, requested_settings)
    }

    /// Returns the currently playing media attributes.
    /// May send either the GetElementAttributes or GetItemAttributes command depending on what
    /// is supported.
    pub fn r#get_media_attributes(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerGetMediaAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#get_media_attributes(self)
    }

    /// Returns the status of the currently playing media.
    pub fn r#get_play_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerGetPlayStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#get_play_status(self)
    }

    /// Request the absolute volume on the peer be changed. Returns the actual volume set by the
    /// peer. Values can range from 0x00 to 0x7F (with 100% volume being 0x7F). You may not get a
    /// volume changed notification event from the remote peer as result of changing this.
    pub fn r#set_absolute_volume(
        &self,
        mut requested_volume: u8,
    ) -> fidl::client::QueryResponseFut<
        ControllerSetAbsoluteVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#set_absolute_volume(self, requested_volume)
    }

    /// Inform target of the controller's battery level.
    pub fn r#inform_battery_status(
        &self,
        mut battery_status: BatteryStatus,
    ) -> fidl::client::QueryResponseFut<
        ControllerInformBatteryStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#inform_battery_status(self, battery_status)
    }

    /// Filters notifications that will be received with [`OnNotification`]. Not all notifications
    /// are supported by all peers. Resetting the notification filter may trigger all requested
    /// notification types to post their current value to [`OnNotification`] immediately.
    ///
    /// The `position_change_interval` argument is used to set the interval in seconds that the
    /// controller client would like to be notified of `TRACK_POS_CHANGED` events.
    /// `position_change_interval` is ignored if `TRACK_POS` is not set. The position change interval
    /// is best effort and not a guarantee and events may arrive more frequently or less frequently
    /// than requested.
    pub fn r#set_notification_filter(
        &self,
        mut notifications: Notifications,
        mut position_change_interval: u32,
    ) -> Result<(), fidl::Error> {
        ControllerProxyInterface::r#set_notification_filter(
            self,
            notifications,
            position_change_interval,
        )
    }

    /// Call to acknowledge handling of a notification from [`OnNotification`].
    pub fn r#notify_notification_handled(&self) -> Result<(), fidl::Error> {
        ControllerProxyInterface::r#notify_notification_handled(self)
    }

    /// Changes the addressed `player_id` on the target when multiple are supported.
    pub fn r#set_addressed_player(
        &self,
        mut player_id: u16,
    ) -> fidl::client::QueryResponseFut<
        ControllerSetAddressedPlayerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#set_addressed_player(self, player_id)
    }

    /// Send an AV\C passthrough key command. Sends both a key down and key up event.
    pub fn r#send_command(
        &self,
        mut command: AvcPanelCommand,
    ) -> fidl::client::QueryResponseFut<
        ControllerSendCommandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#send_command(self, command)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    type GetPlayerApplicationSettingsResponseFut = fidl::client::QueryResponseFut<
        ControllerGetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_player_application_settings(
        &self,
        mut attribute_ids: &[PlayerApplicationSettingAttributeId],
    ) -> Self::GetPlayerApplicationSettingsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerGetPlayerApplicationSettingsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ControllerGetPlayerApplicationSettingsResponse,
                    ControllerError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x681de2da50670120,
            >(_buf?)?;
            Ok(_response.map(|x| x.current_settings))
        }
        self.client.send_query_and_decode::<
            ControllerGetPlayerApplicationSettingsRequest,
            ControllerGetPlayerApplicationSettingsResult,
        >(
            (attribute_ids,),
            0x681de2da50670120,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetPlayerApplicationSettingsResponseFut = fidl::client::QueryResponseFut<
        ControllerSetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_player_application_settings(
        &self,
        mut requested_settings: &PlayerApplicationSettings,
    ) -> Self::SetPlayerApplicationSettingsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerSetPlayerApplicationSettingsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ControllerSetPlayerApplicationSettingsResponse,
                    ControllerError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6a7c9689ea3a589a,
            >(_buf?)?;
            Ok(_response.map(|x| x.set_settings))
        }
        self.client.send_query_and_decode::<
            ControllerSetPlayerApplicationSettingsRequest,
            ControllerSetPlayerApplicationSettingsResult,
        >(
            (requested_settings,),
            0x6a7c9689ea3a589a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMediaAttributesResponseFut = fidl::client::QueryResponseFut<
        ControllerGetMediaAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_media_attributes(&self) -> Self::GetMediaAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerGetMediaAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ControllerGetMediaAttributesResponse, ControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18bd14308ee3173d,
            >(_buf?)?;
            Ok(_response.map(|x| x.attributes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ControllerGetMediaAttributesResult,
        >(
            (),
            0x18bd14308ee3173d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPlayStatusResponseFut = fidl::client::QueryResponseFut<
        ControllerGetPlayStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_play_status(&self) -> Self::GetPlayStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerGetPlayStatusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ControllerGetPlayStatusResponse, ControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x120735bec709fc6d,
            >(_buf?)?;
            Ok(_response.map(|x| x.play_status))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, ControllerGetPlayStatusResult>(
                (),
                0x120735bec709fc6d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetAbsoluteVolumeResponseFut = fidl::client::QueryResponseFut<
        ControllerSetAbsoluteVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_absolute_volume(
        &self,
        mut requested_volume: u8,
    ) -> Self::SetAbsoluteVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerSetAbsoluteVolumeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ControllerSetAbsoluteVolumeResponse, ControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1b8d010e11d05957,
            >(_buf?)?;
            Ok(_response.map(|x| x.set_volume))
        }
        self.client.send_query_and_decode::<
            ControllerSetAbsoluteVolumeRequest,
            ControllerSetAbsoluteVolumeResult,
        >(
            (requested_volume,),
            0x1b8d010e11d05957,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InformBatteryStatusResponseFut = fidl::client::QueryResponseFut<
        ControllerInformBatteryStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#inform_battery_status(
        &self,
        mut battery_status: BatteryStatus,
    ) -> Self::InformBatteryStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerInformBatteryStatusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x11d54fbe9d12c44d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ControllerInformBatteryStatusRequest,
            ControllerInformBatteryStatusResult,
        >(
            (battery_status,),
            0x11d54fbe9d12c44d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_notification_filter(
        &self,
        mut notifications: Notifications,
        mut position_change_interval: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ControllerSetNotificationFilterRequest>(
            (notifications, position_change_interval),
            0x4d8a327745ccd73b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type SetAddressedPlayerResponseFut = fidl::client::QueryResponseFut<
        ControllerSetAddressedPlayerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_addressed_player(&self, mut player_id: u16) -> Self::SetAddressedPlayerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerSetAddressedPlayerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7ffc261f10ee1da5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ControllerSetAddressedPlayerRequest,
            ControllerSetAddressedPlayerResult,
        >(
            (player_id,),
            0x7ffc261f10ee1da5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SendCommandResponseFut = fidl::client::QueryResponseFut<
        ControllerSendCommandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#send_command(&self, mut command: AvcPanelCommand) -> Self::SendCommandResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerSendCommandResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x241324c56b5bc257,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ControllerSendCommandRequest, ControllerSendCommandResult>(
                (command,),
                0x241324c56b5bc257,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

impl futures::Stream for ControllerEventStream {
    type Item = Result<ControllerEvent, 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(ControllerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ControllerEvent {
    OnNotification { timestamp: i64, notification: Notification },
}

impl ControllerEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_notification(self) -> Option<(i64, Notification)> {
        if let ControllerEvent::OnNotification { timestamp, notification } = self {
            Some((timestamp, notification))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`ControllerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ControllerEvent, 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 {
            0x796259451db67281 => {
                let mut out = fidl::new_empty!(
                    ControllerOnNotificationRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerOnNotificationRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ControllerEvent::OnNotification {
                    timestamp: out.timestamp,
                    notification: out.notification,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for ControllerRequestStream {
    type Protocol = ControllerMarker;
    type ControlHandle = ControllerControlHandle;

    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 {
        ControllerControlHandle { 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 ControllerRequestStream {
    type Item = Result<ControllerRequest, 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 ControllerRequestStream 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 {
                    0x681de2da50670120 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerGetPlayerApplicationSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerGetPlayerApplicationSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetPlayerApplicationSettings {
                            attribute_ids: req.attribute_ids,

                            responder: ControllerGetPlayerApplicationSettingsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6a7c9689ea3a589a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerSetPlayerApplicationSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerSetPlayerApplicationSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::SetPlayerApplicationSettings {
                            requested_settings: req.requested_settings,

                            responder: ControllerSetPlayerApplicationSettingsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x18bd14308ee3173d => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetMediaAttributes {
                            responder: ControllerGetMediaAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x120735bec709fc6d => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetPlayStatus {
                            responder: ControllerGetPlayStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1b8d010e11d05957 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerSetAbsoluteVolumeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerSetAbsoluteVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::SetAbsoluteVolume {
                            requested_volume: req.requested_volume,

                            responder: ControllerSetAbsoluteVolumeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x11d54fbe9d12c44d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerInformBatteryStatusRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerInformBatteryStatusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::InformBatteryStatus {
                            battery_status: req.battery_status,

                            responder: ControllerInformBatteryStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4d8a327745ccd73b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerSetNotificationFilterRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerSetNotificationFilterRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::SetNotificationFilter {
                            notifications: req.notifications,
                            position_change_interval: req.position_change_interval,

                            control_handle,
                        })
                    }
                    0x43d3e556557f3bc2 => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::NotifyNotificationHandled { control_handle })
                    }
                    0x7ffc261f10ee1da5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerSetAddressedPlayerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerSetAddressedPlayerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::SetAddressedPlayer {
                            player_id: req.player_id,

                            responder: ControllerSetAddressedPlayerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x241324c56b5bc257 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerSendCommandRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerSendCommandRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::SendCommand {
                            command: req.command,

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

/// Client wrapper for local controller (CT) -> remote target (TG) AVCTP
/// connections between devices for AV/C commands.
///
/// See `BrowseController` protocol note for more detailed explanation on
/// the purpose of this protocol.
#[derive(Debug)]
pub enum ControllerRequest {
    /// Returns currently set player application setting values for the `attribute_ids`.
    /// If no `attribute_ids` are provided, this method will query the TG for all valid
    /// attribute ID's, and return the currently set player application setting values.
    GetPlayerApplicationSettings {
        attribute_ids: Vec<PlayerApplicationSettingAttributeId>,
        responder: ControllerGetPlayerApplicationSettingsResponder,
    },
    /// Sets the player application settings specified by `requested_settings`. Only
    /// settings specified in the input `requested_settings` will be overwritten.
    /// Returns the actual settings that were set.
    /// Settings provided in the `requested_settings` that are unsupported or unknown
    /// will not be set; the returned `set_settings` will include only the settings
    /// that were successfully set on the remote target.
    SetPlayerApplicationSettings {
        requested_settings: PlayerApplicationSettings,
        responder: ControllerSetPlayerApplicationSettingsResponder,
    },
    /// Returns the currently playing media attributes.
    /// May send either the GetElementAttributes or GetItemAttributes command depending on what
    /// is supported.
    GetMediaAttributes { responder: ControllerGetMediaAttributesResponder },
    /// Returns the status of the currently playing media.
    GetPlayStatus { responder: ControllerGetPlayStatusResponder },
    /// Request the absolute volume on the peer be changed. Returns the actual volume set by the
    /// peer. Values can range from 0x00 to 0x7F (with 100% volume being 0x7F). You may not get a
    /// volume changed notification event from the remote peer as result of changing this.
    SetAbsoluteVolume { requested_volume: u8, responder: ControllerSetAbsoluteVolumeResponder },
    /// Inform target of the controller's battery level.
    InformBatteryStatus {
        battery_status: BatteryStatus,
        responder: ControllerInformBatteryStatusResponder,
    },
    /// Filters notifications that will be received with [`OnNotification`]. Not all notifications
    /// are supported by all peers. Resetting the notification filter may trigger all requested
    /// notification types to post their current value to [`OnNotification`] immediately.
    ///
    /// The `position_change_interval` argument is used to set the interval in seconds that the
    /// controller client would like to be notified of `TRACK_POS_CHANGED` events.
    /// `position_change_interval` is ignored if `TRACK_POS` is not set. The position change interval
    /// is best effort and not a guarantee and events may arrive more frequently or less frequently
    /// than requested.
    SetNotificationFilter {
        notifications: Notifications,
        position_change_interval: u32,
        control_handle: ControllerControlHandle,
    },
    /// Call to acknowledge handling of a notification from [`OnNotification`].
    NotifyNotificationHandled { control_handle: ControllerControlHandle },
    /// Changes the addressed `player_id` on the target when multiple are supported.
    SetAddressedPlayer { player_id: u16, responder: ControllerSetAddressedPlayerResponder },
    /// Send an AV\C passthrough key command. Sends both a key down and key up event.
    SendCommand { command: AvcPanelCommand, responder: ControllerSendCommandResponder },
}

impl ControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_player_application_settings(
        self,
    ) -> Option<(
        Vec<PlayerApplicationSettingAttributeId>,
        ControllerGetPlayerApplicationSettingsResponder,
    )> {
        if let ControllerRequest::GetPlayerApplicationSettings { attribute_ids, responder } = self {
            Some((attribute_ids, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_player_application_settings(
        self,
    ) -> Option<(PlayerApplicationSettings, ControllerSetPlayerApplicationSettingsResponder)> {
        if let ControllerRequest::SetPlayerApplicationSettings { requested_settings, responder } =
            self
        {
            Some((requested_settings, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_media_attributes(self) -> Option<(ControllerGetMediaAttributesResponder)> {
        if let ControllerRequest::GetMediaAttributes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_play_status(self) -> Option<(ControllerGetPlayStatusResponder)> {
        if let ControllerRequest::GetPlayStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_absolute_volume(self) -> Option<(u8, ControllerSetAbsoluteVolumeResponder)> {
        if let ControllerRequest::SetAbsoluteVolume { requested_volume, responder } = self {
            Some((requested_volume, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_inform_battery_status(
        self,
    ) -> Option<(BatteryStatus, ControllerInformBatteryStatusResponder)> {
        if let ControllerRequest::InformBatteryStatus { battery_status, responder } = self {
            Some((battery_status, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_notification_filter(
        self,
    ) -> Option<(Notifications, u32, ControllerControlHandle)> {
        if let ControllerRequest::SetNotificationFilter {
            notifications,
            position_change_interval,
            control_handle,
        } = self
        {
            Some((notifications, position_change_interval, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_notification_handled(self) -> Option<(ControllerControlHandle)> {
        if let ControllerRequest::NotifyNotificationHandled { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_addressed_player(self) -> Option<(u16, ControllerSetAddressedPlayerResponder)> {
        if let ControllerRequest::SetAddressedPlayer { player_id, responder } = self {
            Some((player_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_command(self) -> Option<(AvcPanelCommand, ControllerSendCommandResponder)> {
        if let ControllerRequest::SendCommand { command, responder } = self {
            Some((command, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControllerRequest::GetPlayerApplicationSettings { .. } => {
                "get_player_application_settings"
            }
            ControllerRequest::SetPlayerApplicationSettings { .. } => {
                "set_player_application_settings"
            }
            ControllerRequest::GetMediaAttributes { .. } => "get_media_attributes",
            ControllerRequest::GetPlayStatus { .. } => "get_play_status",
            ControllerRequest::SetAbsoluteVolume { .. } => "set_absolute_volume",
            ControllerRequest::InformBatteryStatus { .. } => "inform_battery_status",
            ControllerRequest::SetNotificationFilter { .. } => "set_notification_filter",
            ControllerRequest::NotifyNotificationHandled { .. } => "notify_notification_handled",
            ControllerRequest::SetAddressedPlayer { .. } => "set_addressed_player",
            ControllerRequest::SendCommand { .. } => "send_command",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ControllerControlHandle {
    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 ControllerControlHandle {
    pub fn send_on_notification(
        &self,
        mut timestamp: i64,
        mut notification: &Notification,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<ControllerOnNotificationRequest>(
            (timestamp, notification),
            0,
            0x796259451db67281,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerGetPlayerApplicationSettingsResponder {
    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 ControllerGetPlayerApplicationSettingsResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerGetPlayerApplicationSettingsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&PlayerApplicationSettings, ControllerError>,
    ) -> 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<&PlayerApplicationSettings, ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&PlayerApplicationSettings, ControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ControllerGetPlayerApplicationSettingsResponse,
            ControllerError,
        >>(
            result.map(|current_settings| (current_settings,)),
            self.tx_id,
            0x681de2da50670120,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerSetPlayerApplicationSettingsResponder {
    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 ControllerSetPlayerApplicationSettingsResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerSetPlayerApplicationSettingsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&PlayerApplicationSettings, ControllerError>,
    ) -> 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<&PlayerApplicationSettings, ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&PlayerApplicationSettings, ControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ControllerSetPlayerApplicationSettingsResponse,
            ControllerError,
        >>(
            result.map(|set_settings| (set_settings,)),
            self.tx_id,
            0x6a7c9689ea3a589a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerGetMediaAttributesResponder {
    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 ControllerGetMediaAttributesResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerGetMediaAttributesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&MediaAttributes, ControllerError>,
    ) -> 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<&MediaAttributes, ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&MediaAttributes, ControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ControllerGetMediaAttributesResponse,
            ControllerError,
        >>(
            result.map(|attributes| (attributes,)),
            self.tx_id,
            0x18bd14308ee3173d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerGetPlayStatusResponder {
    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 ControllerGetPlayStatusResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerGetPlayStatusResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&PlayStatus, ControllerError>) -> 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<&PlayStatus, ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&PlayStatus, ControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ControllerGetPlayStatusResponse,
            ControllerError,
        >>(
            result.map(|play_status| (play_status,)),
            self.tx_id,
            0x120735bec709fc6d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerSetAbsoluteVolumeResponder {
    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 ControllerSetAbsoluteVolumeResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerSetAbsoluteVolumeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u8, ControllerError>) -> 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<u8, ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u8, ControllerError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ControllerSetAbsoluteVolumeResponse,
            ControllerError,
        >>(
            result.map(|set_volume| (set_volume,)),
            self.tx_id,
            0x1b8d010e11d05957,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerInformBatteryStatusResponder {
    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 ControllerInformBatteryStatusResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerInformBatteryStatusResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), ControllerError>) -> 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<(), ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerSetAddressedPlayerResponder {
    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 ControllerSetAddressedPlayerResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerSetAddressedPlayerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), ControllerError>) -> 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<(), ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerSendCommandResponder {
    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 ControllerSendCommandResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerSendCommandResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), ControllerError>) -> 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<(), ControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

impl fidl::endpoints::ProtocolMarker for PeerManagerMarker {
    type Proxy = PeerManagerProxy;
    type RequestStream = PeerManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PeerManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.avrcp.PeerManager";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PeerManagerMarker {}
pub type PeerManagerGetBrowseControllerForTargetResult = Result<(), i32>;
pub type PeerManagerGetControllerForTargetResult = Result<(), i32>;
pub type PeerManagerSetAbsoluteVolumeHandlerResult = Result<(), i32>;
pub type PeerManagerRegisterTargetHandlerResult = Result<(), i32>;

pub trait PeerManagerProxyInterface: Send + Sync {
    type GetBrowseControllerForTargetResponseFut: std::future::Future<
            Output = Result<PeerManagerGetBrowseControllerForTargetResult, fidl::Error>,
        > + Send;
    fn r#get_browse_controller_for_target(
        &self,
        peer_id: &fidl_fuchsia_bluetooth::PeerId,
        client: fidl::endpoints::ServerEnd<BrowseControllerMarker>,
    ) -> Self::GetBrowseControllerForTargetResponseFut;
    type GetControllerForTargetResponseFut: std::future::Future<Output = Result<PeerManagerGetControllerForTargetResult, fidl::Error>>
        + Send;
    fn r#get_controller_for_target(
        &self,
        peer_id: &fidl_fuchsia_bluetooth::PeerId,
        client: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::GetControllerForTargetResponseFut;
    type SetAbsoluteVolumeHandlerResponseFut: std::future::Future<Output = Result<PeerManagerSetAbsoluteVolumeHandlerResult, fidl::Error>>
        + Send;
    fn r#set_absolute_volume_handler(
        &self,
        handler: fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
    ) -> Self::SetAbsoluteVolumeHandlerResponseFut;
    type RegisterTargetHandlerResponseFut: std::future::Future<Output = Result<PeerManagerRegisterTargetHandlerResult, fidl::Error>>
        + Send;
    fn r#register_target_handler(
        &self,
        handler: fidl::endpoints::ClientEnd<TargetHandlerMarker>,
    ) -> Self::RegisterTargetHandlerResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PeerManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PeerManagerSynchronousProxy {
    type Proxy = PeerManagerProxy;
    type Protocol = PeerManagerMarker;

    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 PeerManagerSynchronousProxy {
    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<PeerManagerEvent, fidl::Error> {
        PeerManagerEvent::decode(self.client.wait_for_event::<PeerManagerMarker>(deadline)?)
    }

    /// Returns a browse controller client to a remote target (TG) service at
    /// the peer specified by `peer_id`.
    pub fn r#get_browse_controller_for_target(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut client: fidl::endpoints::ServerEnd<BrowseControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerManagerGetBrowseControllerForTargetResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerManagerGetBrowseControllerForTargetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PeerManagerMarker,
        >(
            (peer_id, client,),
            0x5b75bbb8d58a6d49,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns a controller client to a remote target (TG) service at the peer specified by
    /// `peer_id`.
    pub fn r#get_controller_for_target(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut client: fidl::endpoints::ServerEnd<ControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerManagerGetControllerForTargetResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerManagerGetControllerForTargetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PeerManagerMarker,
        >(
            (peer_id, client,),
            0x25d36e51516bc3b4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set the absolute volume handler.  Only one handler may be set  at at time.
    /// If a second handler is registered it will be dropped and an error will
    /// be returned.
    pub fn r#set_absolute_volume_handler(
        &self,
        mut handler: fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerManagerSetAbsoluteVolumeHandlerResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerManagerSetAbsoluteVolumeHandlerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PeerManagerMarker,
        >(
            (handler,),
            0x39a465c63e9f918c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Sets an implementation of target handler that will vend delegates for each incoming
    /// remote TG -> local CT connections to handle the commands being sent by the remote TG.
    pub fn r#register_target_handler(
        &self,
        mut handler: fidl::endpoints::ClientEnd<TargetHandlerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerManagerRegisterTargetHandlerResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerManagerRegisterTargetHandlerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PeerManagerMarker,
        >(
            (handler,),
            0x4bc919acb791bdb3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PeerManagerProxy {
    type Protocol = PeerManagerMarker;

    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 PeerManagerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.avrcp/PeerManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PeerManagerMarker 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) -> PeerManagerEventStream {
        PeerManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a browse controller client to a remote target (TG) service at
    /// the peer specified by `peer_id`.
    pub fn r#get_browse_controller_for_target(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut client: fidl::endpoints::ServerEnd<BrowseControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeerManagerGetBrowseControllerForTargetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerManagerProxyInterface::r#get_browse_controller_for_target(self, peer_id, client)
    }

    /// Returns a controller client to a remote target (TG) service at the peer specified by
    /// `peer_id`.
    pub fn r#get_controller_for_target(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut client: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeerManagerGetControllerForTargetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerManagerProxyInterface::r#get_controller_for_target(self, peer_id, client)
    }

    /// Set the absolute volume handler.  Only one handler may be set  at at time.
    /// If a second handler is registered it will be dropped and an error will
    /// be returned.
    pub fn r#set_absolute_volume_handler(
        &self,
        mut handler: fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeerManagerSetAbsoluteVolumeHandlerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerManagerProxyInterface::r#set_absolute_volume_handler(self, handler)
    }

    /// Sets an implementation of target handler that will vend delegates for each incoming
    /// remote TG -> local CT connections to handle the commands being sent by the remote TG.
    pub fn r#register_target_handler(
        &self,
        mut handler: fidl::endpoints::ClientEnd<TargetHandlerMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeerManagerRegisterTargetHandlerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerManagerProxyInterface::r#register_target_handler(self, handler)
    }
}

impl PeerManagerProxyInterface for PeerManagerProxy {
    type GetBrowseControllerForTargetResponseFut = fidl::client::QueryResponseFut<
        PeerManagerGetBrowseControllerForTargetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_browse_controller_for_target(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut client: fidl::endpoints::ServerEnd<BrowseControllerMarker>,
    ) -> Self::GetBrowseControllerForTargetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerManagerGetBrowseControllerForTargetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5b75bbb8d58a6d49,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeerManagerGetBrowseControllerForTargetRequest,
            PeerManagerGetBrowseControllerForTargetResult,
        >(
            (peer_id, client,),
            0x5b75bbb8d58a6d49,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetControllerForTargetResponseFut = fidl::client::QueryResponseFut<
        PeerManagerGetControllerForTargetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_controller_for_target(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut client: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::GetControllerForTargetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerManagerGetControllerForTargetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25d36e51516bc3b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeerManagerGetControllerForTargetRequest,
            PeerManagerGetControllerForTargetResult,
        >(
            (peer_id, client,),
            0x25d36e51516bc3b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetAbsoluteVolumeHandlerResponseFut = fidl::client::QueryResponseFut<
        PeerManagerSetAbsoluteVolumeHandlerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_absolute_volume_handler(
        &self,
        mut handler: fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
    ) -> Self::SetAbsoluteVolumeHandlerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerManagerSetAbsoluteVolumeHandlerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x39a465c63e9f918c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeerManagerSetAbsoluteVolumeHandlerRequest,
            PeerManagerSetAbsoluteVolumeHandlerResult,
        >(
            (handler,),
            0x39a465c63e9f918c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RegisterTargetHandlerResponseFut = fidl::client::QueryResponseFut<
        PeerManagerRegisterTargetHandlerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#register_target_handler(
        &self,
        mut handler: fidl::endpoints::ClientEnd<TargetHandlerMarker>,
    ) -> Self::RegisterTargetHandlerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerManagerRegisterTargetHandlerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4bc919acb791bdb3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeerManagerRegisterTargetHandlerRequest,
            PeerManagerRegisterTargetHandlerResult,
        >(
            (handler,),
            0x4bc919acb791bdb3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for PeerManagerEventStream {
    type Item = Result<PeerManagerEvent, 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(PeerManagerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl PeerManagerEvent {
    /// Decodes a message buffer as a [`PeerManagerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PeerManagerEvent, 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: <PeerManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for PeerManagerRequestStream {
    type Protocol = PeerManagerMarker;
    type ControlHandle = PeerManagerControlHandle;

    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 {
        PeerManagerControlHandle { 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 PeerManagerRequestStream {
    type Item = Result<PeerManagerRequest, 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 PeerManagerRequestStream 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 {
                    0x5b75bbb8d58a6d49 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerManagerGetBrowseControllerForTargetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerManagerGetBrowseControllerForTargetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerManagerControlHandle { inner: this.inner.clone() };
                        Ok(PeerManagerRequest::GetBrowseControllerForTarget {
                            peer_id: req.peer_id,
                            client: req.client,

                            responder: PeerManagerGetBrowseControllerForTargetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25d36e51516bc3b4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerManagerGetControllerForTargetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerManagerGetControllerForTargetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerManagerControlHandle { inner: this.inner.clone() };
                        Ok(PeerManagerRequest::GetControllerForTarget {
                            peer_id: req.peer_id,
                            client: req.client,

                            responder: PeerManagerGetControllerForTargetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x39a465c63e9f918c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerManagerSetAbsoluteVolumeHandlerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerManagerSetAbsoluteVolumeHandlerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerManagerControlHandle { inner: this.inner.clone() };
                        Ok(PeerManagerRequest::SetAbsoluteVolumeHandler {
                            handler: req.handler,

                            responder: PeerManagerSetAbsoluteVolumeHandlerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4bc919acb791bdb3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerManagerRegisterTargetHandlerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerManagerRegisterTargetHandlerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerManagerControlHandle { inner: this.inner.clone() };
                        Ok(PeerManagerRequest::RegisterTargetHandler {
                            handler: req.handler,

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

#[derive(Debug)]
pub enum PeerManagerRequest {
    /// Returns a browse controller client to a remote target (TG) service at
    /// the peer specified by `peer_id`.
    GetBrowseControllerForTarget {
        peer_id: fidl_fuchsia_bluetooth::PeerId,
        client: fidl::endpoints::ServerEnd<BrowseControllerMarker>,
        responder: PeerManagerGetBrowseControllerForTargetResponder,
    },
    /// Returns a controller client to a remote target (TG) service at the peer specified by
    /// `peer_id`.
    GetControllerForTarget {
        peer_id: fidl_fuchsia_bluetooth::PeerId,
        client: fidl::endpoints::ServerEnd<ControllerMarker>,
        responder: PeerManagerGetControllerForTargetResponder,
    },
    /// Set the absolute volume handler.  Only one handler may be set  at at time.
    /// If a second handler is registered it will be dropped and an error will
    /// be returned.
    SetAbsoluteVolumeHandler {
        handler: fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
        responder: PeerManagerSetAbsoluteVolumeHandlerResponder,
    },
    /// Sets an implementation of target handler that will vend delegates for each incoming
    /// remote TG -> local CT connections to handle the commands being sent by the remote TG.
    RegisterTargetHandler {
        handler: fidl::endpoints::ClientEnd<TargetHandlerMarker>,
        responder: PeerManagerRegisterTargetHandlerResponder,
    },
}

impl PeerManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_browse_controller_for_target(
        self,
    ) -> Option<(
        fidl_fuchsia_bluetooth::PeerId,
        fidl::endpoints::ServerEnd<BrowseControllerMarker>,
        PeerManagerGetBrowseControllerForTargetResponder,
    )> {
        if let PeerManagerRequest::GetBrowseControllerForTarget { peer_id, client, responder } =
            self
        {
            Some((peer_id, client, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_controller_for_target(
        self,
    ) -> Option<(
        fidl_fuchsia_bluetooth::PeerId,
        fidl::endpoints::ServerEnd<ControllerMarker>,
        PeerManagerGetControllerForTargetResponder,
    )> {
        if let PeerManagerRequest::GetControllerForTarget { peer_id, client, responder } = self {
            Some((peer_id, client, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_absolute_volume_handler(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
        PeerManagerSetAbsoluteVolumeHandlerResponder,
    )> {
        if let PeerManagerRequest::SetAbsoluteVolumeHandler { handler, responder } = self {
            Some((handler, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_target_handler(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<TargetHandlerMarker>,
        PeerManagerRegisterTargetHandlerResponder,
    )> {
        if let PeerManagerRequest::RegisterTargetHandler { handler, responder } = self {
            Some((handler, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PeerManagerRequest::GetBrowseControllerForTarget { .. } => {
                "get_browse_controller_for_target"
            }
            PeerManagerRequest::GetControllerForTarget { .. } => "get_controller_for_target",
            PeerManagerRequest::SetAbsoluteVolumeHandler { .. } => "set_absolute_volume_handler",
            PeerManagerRequest::RegisterTargetHandler { .. } => "register_target_handler",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for PeerManagerControlHandle {
    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 PeerManagerControlHandle {}

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

/// Set the the channel to be shutdown (see [`PeerManagerControlHandle::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 PeerManagerGetBrowseControllerForTargetResponder {
    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 PeerManagerGetBrowseControllerForTargetResponder {
    type ControlHandle = PeerManagerControlHandle;

    fn control_handle(&self) -> &PeerManagerControlHandle {
        &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 PeerManagerGetBrowseControllerForTargetResponder {
    /// 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,
                0x5b75bbb8d58a6d49,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`PeerManagerControlHandle::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 PeerManagerGetControllerForTargetResponder {
    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 PeerManagerGetControllerForTargetResponder {
    type ControlHandle = PeerManagerControlHandle;

    fn control_handle(&self) -> &PeerManagerControlHandle {
        &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 PeerManagerGetControllerForTargetResponder {
    /// 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,
                0x25d36e51516bc3b4,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`PeerManagerControlHandle::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 PeerManagerSetAbsoluteVolumeHandlerResponder {
    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 PeerManagerSetAbsoluteVolumeHandlerResponder {
    type ControlHandle = PeerManagerControlHandle;

    fn control_handle(&self) -> &PeerManagerControlHandle {
        &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 PeerManagerSetAbsoluteVolumeHandlerResponder {
    /// 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,
                0x39a465c63e9f918c,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`PeerManagerControlHandle::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 PeerManagerRegisterTargetHandlerResponder {
    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 PeerManagerRegisterTargetHandlerResponder {
    type ControlHandle = PeerManagerControlHandle;

    fn control_handle(&self) -> &PeerManagerControlHandle {
        &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 PeerManagerRegisterTargetHandlerResponder {
    /// 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,
                0x4bc919acb791bdb3,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for TargetHandlerMarker {
    type Proxy = TargetHandlerProxy;
    type RequestStream = TargetHandlerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TargetHandlerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) TargetHandler";
}
pub type TargetHandlerGetEventsSupportedResult = Result<Vec<NotificationEvent>, TargetAvcError>;
pub type TargetHandlerGetMediaAttributesResult = Result<MediaAttributes, TargetAvcError>;
pub type TargetHandlerGetPlayStatusResult = Result<PlayStatus, TargetAvcError>;
pub type TargetHandlerSendCommandResult = Result<(), TargetPassthroughError>;
pub type TargetHandlerListPlayerApplicationSettingAttributesResult =
    Result<Vec<PlayerApplicationSettingAttributeId>, TargetAvcError>;
pub type TargetHandlerGetPlayerApplicationSettingsResult =
    Result<PlayerApplicationSettings, TargetAvcError>;
pub type TargetHandlerSetPlayerApplicationSettingsResult =
    Result<PlayerApplicationSettings, TargetAvcError>;
pub type TargetHandlerGetNotificationResult = Result<Notification, TargetAvcError>;
pub type TargetHandlerWatchNotificationResult = Result<Notification, TargetAvcError>;
pub type TargetHandlerSetAddressedPlayerResult = Result<(), TargetAvcError>;
pub type TargetHandlerGetMediaPlayerItemsResult = Result<Vec<MediaPlayerItem>, TargetAvcError>;

pub trait TargetHandlerProxyInterface: Send + Sync {
    type GetEventsSupportedResponseFut: std::future::Future<Output = Result<TargetHandlerGetEventsSupportedResult, fidl::Error>>
        + Send;
    fn r#get_events_supported(&self) -> Self::GetEventsSupportedResponseFut;
    type GetMediaAttributesResponseFut: std::future::Future<Output = Result<TargetHandlerGetMediaAttributesResult, fidl::Error>>
        + Send;
    fn r#get_media_attributes(&self) -> Self::GetMediaAttributesResponseFut;
    type GetPlayStatusResponseFut: std::future::Future<Output = Result<TargetHandlerGetPlayStatusResult, fidl::Error>>
        + Send;
    fn r#get_play_status(&self) -> Self::GetPlayStatusResponseFut;
    type SendCommandResponseFut: std::future::Future<Output = Result<TargetHandlerSendCommandResult, fidl::Error>>
        + Send;
    fn r#send_command(
        &self,
        command: AvcPanelCommand,
        pressed: bool,
    ) -> Self::SendCommandResponseFut;
    type ListPlayerApplicationSettingAttributesResponseFut: std::future::Future<
            Output = Result<TargetHandlerListPlayerApplicationSettingAttributesResult, fidl::Error>,
        > + Send;
    fn r#list_player_application_setting_attributes(
        &self,
    ) -> Self::ListPlayerApplicationSettingAttributesResponseFut;
    type GetPlayerApplicationSettingsResponseFut: std::future::Future<
            Output = Result<TargetHandlerGetPlayerApplicationSettingsResult, fidl::Error>,
        > + Send;
    fn r#get_player_application_settings(
        &self,
        attribute_ids: &[PlayerApplicationSettingAttributeId],
    ) -> Self::GetPlayerApplicationSettingsResponseFut;
    type SetPlayerApplicationSettingsResponseFut: std::future::Future<
            Output = Result<TargetHandlerSetPlayerApplicationSettingsResult, fidl::Error>,
        > + Send;
    fn r#set_player_application_settings(
        &self,
        requested_settings: &PlayerApplicationSettings,
    ) -> Self::SetPlayerApplicationSettingsResponseFut;
    type GetNotificationResponseFut: std::future::Future<Output = Result<TargetHandlerGetNotificationResult, fidl::Error>>
        + Send;
    fn r#get_notification(&self, event_id: NotificationEvent) -> Self::GetNotificationResponseFut;
    type WatchNotificationResponseFut: std::future::Future<Output = Result<TargetHandlerWatchNotificationResult, fidl::Error>>
        + Send;
    fn r#watch_notification(
        &self,
        event_id: NotificationEvent,
        current: &Notification,
        pos_change_interval: u32,
    ) -> Self::WatchNotificationResponseFut;
    type SetAddressedPlayerResponseFut: std::future::Future<Output = Result<TargetHandlerSetAddressedPlayerResult, fidl::Error>>
        + Send;
    fn r#set_addressed_player(
        &self,
        player_id: &AddressedPlayerId,
    ) -> Self::SetAddressedPlayerResponseFut;
    type GetMediaPlayerItemsResponseFut: std::future::Future<Output = Result<TargetHandlerGetMediaPlayerItemsResult, fidl::Error>>
        + Send;
    fn r#get_media_player_items(&self) -> Self::GetMediaPlayerItemsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TargetHandlerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TargetHandlerSynchronousProxy {
    type Proxy = TargetHandlerProxy;
    type Protocol = TargetHandlerMarker;

    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 TargetHandlerSynchronousProxy {
    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<TargetHandlerEvent, fidl::Error> {
        TargetHandlerEvent::decode(self.client.wait_for_event::<TargetHandlerMarker>(deadline)?)
    }

    /// Returns the event notification ids that are supported by the TG.
    pub fn r#get_events_supported(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerGetEventsSupportedResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                TargetHandlerGetEventsSupportedResponse,
                TargetAvcError,
            >, TargetHandlerMarker>(
                (),
                0x54bb8d817d5e1257,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.notification_ids))
    }

    /// Returns the currently playing media attributes.
    /// May send either the GetElementAttributes or GetItemAttributes command depending on what
    /// is supported.
    pub fn r#get_media_attributes(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerGetMediaAttributesResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                TargetHandlerGetMediaAttributesResponse,
                TargetAvcError,
            >, TargetHandlerMarker>(
                (),
                0x629f354d2805daf5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.attributes))
    }

    /// Returns the status of the currently playing media.
    pub fn r#get_play_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerGetPlayStatusResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                TargetHandlerGetPlayStatusResponse,
                TargetAvcError,
            >, TargetHandlerMarker>(
                (),
                0x24a4816300e14d89,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.play_status))
    }

    /// Send an AV\C passthrough key command.
    /// If `key_pressed`, then the AV\C passthrough command shall be interpreted as a key
    /// press down event. Otherwise, the command shall be interpreted as a key release event.
    pub fn r#send_command(
        &self,
        mut command: AvcPanelCommand,
        mut pressed: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerSendCommandResult, fidl::Error> {
        let _response =
            self.client.send_query::<TargetHandlerSendCommandRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                TargetPassthroughError,
            >, TargetHandlerMarker>(
                (command, pressed),
                0x69e063a8f6ab7b87,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Request the target device to provide all the target supported player application
    /// setting attributes.
    pub fn r#list_player_application_setting_attributes(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerListPlayerApplicationSettingAttributesResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                TargetHandlerListPlayerApplicationSettingAttributesResponse,
                TargetAvcError,
            >, TargetHandlerMarker>(
                (),
                0xdfa38da6a60b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.attributes))
    }

    /// Returns currently set player application setting values for the `attribute_ids`.
    /// If no `attribute_ids` are provided, this method will query the TG for all valid
    /// attribute ID's, and return the currently set player application setting values.
    pub fn r#get_player_application_settings(
        &self,
        mut attribute_ids: &[PlayerApplicationSettingAttributeId],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerGetPlayerApplicationSettingsResult, fidl::Error> {
        let _response = self.client.send_query::<
            TargetHandlerGetPlayerApplicationSettingsRequest,
            fidl::encoding::ResultType<TargetHandlerGetPlayerApplicationSettingsResponse, TargetAvcError>,
            TargetHandlerMarker,
        >(
            (attribute_ids,),
            0x4273f96bdb752751,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.current_settings))
    }

    /// Sets the player application settings specified by `requested_settings`. Only
    /// settings specified in the input `requested_settings` will be overwritten.
    /// Returns the actual settings that were set.
    /// Settings provided in the `requested_settings` that are unsupported or unknown
    /// will not be set; and `SetPlayerApplicationSettings` will not return an error.
    /// Instead, the returned `set_settings` will include only the settings that were
    /// successfully set on the remote target.
    pub fn r#set_player_application_settings(
        &self,
        mut requested_settings: &PlayerApplicationSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerSetPlayerApplicationSettingsResult, fidl::Error> {
        let _response = self.client.send_query::<
            TargetHandlerSetPlayerApplicationSettingsRequest,
            fidl::encoding::ResultType<TargetHandlerSetPlayerApplicationSettingsResponse, TargetAvcError>,
            TargetHandlerMarker,
        >(
            (requested_settings,),
            0x636dd18255e01998,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.set_settings))
    }

    /// Returns the current value for the notification specified by `event_id`.
    pub fn r#get_notification(
        &self,
        mut event_id: NotificationEvent,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerGetNotificationResult, fidl::Error> {
        let _response = self.client.send_query::<
            TargetHandlerGetNotificationRequest,
            fidl::encoding::ResultType<TargetHandlerGetNotificationResponse, TargetAvcError>,
            TargetHandlerMarker,
        >(
            (event_id,),
            0x60c7792539a032f1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.current_value))
    }

    /// Returns the changed value of the notification specified by 'event_id'.
    /// A changed value refers to any value that is different than the input parameter
    /// `current` Notification value.
    /// `WatchNotification` will not respond until the Notification value associated
    /// with `event_id` has changed from the `current` Notification.
    pub fn r#watch_notification(
        &self,
        mut event_id: NotificationEvent,
        mut current: &Notification,
        mut pos_change_interval: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerWatchNotificationResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<TargetHandlerWatchNotificationRequest, fidl::encoding::ResultType<
                    TargetHandlerWatchNotificationResponse,
                    TargetAvcError,
                >, TargetHandlerMarker>(
                    (event_id, current, pos_change_interval),
                    0x2a513434cf256e5f,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x.new_value))
    }

    /// Changes the addressed `player_id` on the target when multiple are supported.
    pub fn r#set_addressed_player(
        &self,
        mut player_id: &AddressedPlayerId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerSetAddressedPlayerResult, fidl::Error> {
        let _response = self.client.send_query::<
            TargetHandlerSetAddressedPlayerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, TargetAvcError>,
            TargetHandlerMarker,
        >(
            (player_id,),
            0x6724ae8288c34d2f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns a list of media player information about the players on the target.
    pub fn r#get_media_player_items(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TargetHandlerGetMediaPlayerItemsResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                TargetHandlerGetMediaPlayerItemsResponse,
                TargetAvcError,
            >, TargetHandlerMarker>(
                (),
                0x736668f5aa3a8246,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.items))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TargetHandlerProxy {
    type Protocol = TargetHandlerMarker;

    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 TargetHandlerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.avrcp/TargetHandler.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <TargetHandlerMarker 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) -> TargetHandlerEventStream {
        TargetHandlerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the event notification ids that are supported by the TG.
    pub fn r#get_events_supported(
        &self,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerGetEventsSupportedResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#get_events_supported(self)
    }

    /// Returns the currently playing media attributes.
    /// May send either the GetElementAttributes or GetItemAttributes command depending on what
    /// is supported.
    pub fn r#get_media_attributes(
        &self,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerGetMediaAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#get_media_attributes(self)
    }

    /// Returns the status of the currently playing media.
    pub fn r#get_play_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerGetPlayStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#get_play_status(self)
    }

    /// Send an AV\C passthrough key command.
    /// If `key_pressed`, then the AV\C passthrough command shall be interpreted as a key
    /// press down event. Otherwise, the command shall be interpreted as a key release event.
    pub fn r#send_command(
        &self,
        mut command: AvcPanelCommand,
        mut pressed: bool,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerSendCommandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#send_command(self, command, pressed)
    }

    /// Request the target device to provide all the target supported player application
    /// setting attributes.
    pub fn r#list_player_application_setting_attributes(
        &self,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerListPlayerApplicationSettingAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#list_player_application_setting_attributes(self)
    }

    /// Returns currently set player application setting values for the `attribute_ids`.
    /// If no `attribute_ids` are provided, this method will query the TG for all valid
    /// attribute ID's, and return the currently set player application setting values.
    pub fn r#get_player_application_settings(
        &self,
        mut attribute_ids: &[PlayerApplicationSettingAttributeId],
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerGetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#get_player_application_settings(self, attribute_ids)
    }

    /// Sets the player application settings specified by `requested_settings`. Only
    /// settings specified in the input `requested_settings` will be overwritten.
    /// Returns the actual settings that were set.
    /// Settings provided in the `requested_settings` that are unsupported or unknown
    /// will not be set; and `SetPlayerApplicationSettings` will not return an error.
    /// Instead, the returned `set_settings` will include only the settings that were
    /// successfully set on the remote target.
    pub fn r#set_player_application_settings(
        &self,
        mut requested_settings: &PlayerApplicationSettings,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerSetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#set_player_application_settings(self, requested_settings)
    }

    /// Returns the current value for the notification specified by `event_id`.
    pub fn r#get_notification(
        &self,
        mut event_id: NotificationEvent,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerGetNotificationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#get_notification(self, event_id)
    }

    /// Returns the changed value of the notification specified by 'event_id'.
    /// A changed value refers to any value that is different than the input parameter
    /// `current` Notification value.
    /// `WatchNotification` will not respond until the Notification value associated
    /// with `event_id` has changed from the `current` Notification.
    pub fn r#watch_notification(
        &self,
        mut event_id: NotificationEvent,
        mut current: &Notification,
        mut pos_change_interval: u32,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerWatchNotificationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#watch_notification(
            self,
            event_id,
            current,
            pos_change_interval,
        )
    }

    /// Changes the addressed `player_id` on the target when multiple are supported.
    pub fn r#set_addressed_player(
        &self,
        mut player_id: &AddressedPlayerId,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerSetAddressedPlayerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#set_addressed_player(self, player_id)
    }

    /// Returns a list of media player information about the players on the target.
    pub fn r#get_media_player_items(
        &self,
    ) -> fidl::client::QueryResponseFut<
        TargetHandlerGetMediaPlayerItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TargetHandlerProxyInterface::r#get_media_player_items(self)
    }
}

impl TargetHandlerProxyInterface for TargetHandlerProxy {
    type GetEventsSupportedResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerGetEventsSupportedResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_events_supported(&self) -> Self::GetEventsSupportedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerGetEventsSupportedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<TargetHandlerGetEventsSupportedResponse, TargetAvcError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54bb8d817d5e1257,
            >(_buf?)?;
            Ok(_response.map(|x| x.notification_ids))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            TargetHandlerGetEventsSupportedResult,
        >(
            (),
            0x54bb8d817d5e1257,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMediaAttributesResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerGetMediaAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_media_attributes(&self) -> Self::GetMediaAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerGetMediaAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<TargetHandlerGetMediaAttributesResponse, TargetAvcError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x629f354d2805daf5,
            >(_buf?)?;
            Ok(_response.map(|x| x.attributes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            TargetHandlerGetMediaAttributesResult,
        >(
            (),
            0x629f354d2805daf5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPlayStatusResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerGetPlayStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_play_status(&self) -> Self::GetPlayStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerGetPlayStatusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<TargetHandlerGetPlayStatusResponse, TargetAvcError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24a4816300e14d89,
            >(_buf?)?;
            Ok(_response.map(|x| x.play_status))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            TargetHandlerGetPlayStatusResult,
        >(
            (),
            0x24a4816300e14d89,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SendCommandResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerSendCommandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#send_command(
        &self,
        mut command: AvcPanelCommand,
        mut pressed: bool,
    ) -> Self::SendCommandResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerSendCommandResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, TargetPassthroughError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x69e063a8f6ab7b87,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            TargetHandlerSendCommandRequest,
            TargetHandlerSendCommandResult,
        >(
            (command, pressed,),
            0x69e063a8f6ab7b87,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ListPlayerApplicationSettingAttributesResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerListPlayerApplicationSettingAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#list_player_application_setting_attributes(
        &self,
    ) -> Self::ListPlayerApplicationSettingAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerListPlayerApplicationSettingAttributesResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    TargetHandlerListPlayerApplicationSettingAttributesResponse,
                    TargetAvcError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xdfa38da6a60b2,
            >(_buf?)?;
            Ok(_response.map(|x| x.attributes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            TargetHandlerListPlayerApplicationSettingAttributesResult,
        >(
            (),
            0xdfa38da6a60b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPlayerApplicationSettingsResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerGetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_player_application_settings(
        &self,
        mut attribute_ids: &[PlayerApplicationSettingAttributeId],
    ) -> Self::GetPlayerApplicationSettingsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerGetPlayerApplicationSettingsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    TargetHandlerGetPlayerApplicationSettingsResponse,
                    TargetAvcError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4273f96bdb752751,
            >(_buf?)?;
            Ok(_response.map(|x| x.current_settings))
        }
        self.client.send_query_and_decode::<
            TargetHandlerGetPlayerApplicationSettingsRequest,
            TargetHandlerGetPlayerApplicationSettingsResult,
        >(
            (attribute_ids,),
            0x4273f96bdb752751,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetPlayerApplicationSettingsResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerSetPlayerApplicationSettingsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_player_application_settings(
        &self,
        mut requested_settings: &PlayerApplicationSettings,
    ) -> Self::SetPlayerApplicationSettingsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerSetPlayerApplicationSettingsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    TargetHandlerSetPlayerApplicationSettingsResponse,
                    TargetAvcError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x636dd18255e01998,
            >(_buf?)?;
            Ok(_response.map(|x| x.set_settings))
        }
        self.client.send_query_and_decode::<
            TargetHandlerSetPlayerApplicationSettingsRequest,
            TargetHandlerSetPlayerApplicationSettingsResult,
        >(
            (requested_settings,),
            0x636dd18255e01998,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetNotificationResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerGetNotificationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_notification(
        &self,
        mut event_id: NotificationEvent,
    ) -> Self::GetNotificationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerGetNotificationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<TargetHandlerGetNotificationResponse, TargetAvcError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x60c7792539a032f1,
            >(_buf?)?;
            Ok(_response.map(|x| x.current_value))
        }
        self.client.send_query_and_decode::<
            TargetHandlerGetNotificationRequest,
            TargetHandlerGetNotificationResult,
        >(
            (event_id,),
            0x60c7792539a032f1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchNotificationResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerWatchNotificationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_notification(
        &self,
        mut event_id: NotificationEvent,
        mut current: &Notification,
        mut pos_change_interval: u32,
    ) -> Self::WatchNotificationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerWatchNotificationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<TargetHandlerWatchNotificationResponse, TargetAvcError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a513434cf256e5f,
            >(_buf?)?;
            Ok(_response.map(|x| x.new_value))
        }
        self.client.send_query_and_decode::<
            TargetHandlerWatchNotificationRequest,
            TargetHandlerWatchNotificationResult,
        >(
            (event_id, current, pos_change_interval,),
            0x2a513434cf256e5f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetAddressedPlayerResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerSetAddressedPlayerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_addressed_player(
        &self,
        mut player_id: &AddressedPlayerId,
    ) -> Self::SetAddressedPlayerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerSetAddressedPlayerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, TargetAvcError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6724ae8288c34d2f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            TargetHandlerSetAddressedPlayerRequest,
            TargetHandlerSetAddressedPlayerResult,
        >(
            (player_id,),
            0x6724ae8288c34d2f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMediaPlayerItemsResponseFut = fidl::client::QueryResponseFut<
        TargetHandlerGetMediaPlayerItemsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_media_player_items(&self) -> Self::GetMediaPlayerItemsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TargetHandlerGetMediaPlayerItemsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    TargetHandlerGetMediaPlayerItemsResponse,
                    TargetAvcError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x736668f5aa3a8246,
            >(_buf?)?;
            Ok(_response.map(|x| x.items))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            TargetHandlerGetMediaPlayerItemsResult,
        >(
            (),
            0x736668f5aa3a8246,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for TargetHandlerEventStream {
    type Item = Result<TargetHandlerEvent, 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(TargetHandlerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl TargetHandlerEvent {
    /// Decodes a message buffer as a [`TargetHandlerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<TargetHandlerEvent, 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: <TargetHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for TargetHandlerRequestStream {
    type Protocol = TargetHandlerMarker;
    type ControlHandle = TargetHandlerControlHandle;

    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 {
        TargetHandlerControlHandle { 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 TargetHandlerRequestStream {
    type Item = Result<TargetHandlerRequest, 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 TargetHandlerRequestStream 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 {
                    0x54bb8d817d5e1257 => {
                        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 =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::GetEventsSupported {
                            responder: TargetHandlerGetEventsSupportedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x629f354d2805daf5 => {
                        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 =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::GetMediaAttributes {
                            responder: TargetHandlerGetMediaAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24a4816300e14d89 => {
                        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 =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::GetPlayStatus {
                            responder: TargetHandlerGetPlayStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x69e063a8f6ab7b87 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TargetHandlerSendCommandRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TargetHandlerSendCommandRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::SendCommand {
                            command: req.command,
                            pressed: req.pressed,

                            responder: TargetHandlerSendCommandResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xdfa38da6a60b2 => {
                        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 =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::ListPlayerApplicationSettingAttributes {
                            responder:
                                TargetHandlerListPlayerApplicationSettingAttributesResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x4273f96bdb752751 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TargetHandlerGetPlayerApplicationSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TargetHandlerGetPlayerApplicationSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::GetPlayerApplicationSettings {
                            attribute_ids: req.attribute_ids,

                            responder: TargetHandlerGetPlayerApplicationSettingsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x636dd18255e01998 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TargetHandlerSetPlayerApplicationSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TargetHandlerSetPlayerApplicationSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::SetPlayerApplicationSettings {
                            requested_settings: req.requested_settings,

                            responder: TargetHandlerSetPlayerApplicationSettingsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x60c7792539a032f1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TargetHandlerGetNotificationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TargetHandlerGetNotificationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::GetNotification {
                            event_id: req.event_id,

                            responder: TargetHandlerGetNotificationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2a513434cf256e5f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TargetHandlerWatchNotificationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TargetHandlerWatchNotificationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::WatchNotification {
                            event_id: req.event_id,
                            current: req.current,
                            pos_change_interval: req.pos_change_interval,

                            responder: TargetHandlerWatchNotificationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6724ae8288c34d2f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TargetHandlerSetAddressedPlayerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TargetHandlerSetAddressedPlayerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::SetAddressedPlayer {
                            player_id: req.player_id,

                            responder: TargetHandlerSetAddressedPlayerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x736668f5aa3a8246 => {
                        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 =
                            TargetHandlerControlHandle { inner: this.inner.clone() };
                        Ok(TargetHandlerRequest::GetMediaPlayerItems {
                            responder: TargetHandlerGetMediaPlayerItemsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <TargetHandlerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Client wrapper for the local target.
/// A client is a high level construct and does not represent a connection with a device.
#[derive(Debug)]
pub enum TargetHandlerRequest {
    /// Returns the event notification ids that are supported by the TG.
    GetEventsSupported { responder: TargetHandlerGetEventsSupportedResponder },
    /// Returns the currently playing media attributes.
    /// May send either the GetElementAttributes or GetItemAttributes command depending on what
    /// is supported.
    GetMediaAttributes { responder: TargetHandlerGetMediaAttributesResponder },
    /// Returns the status of the currently playing media.
    GetPlayStatus { responder: TargetHandlerGetPlayStatusResponder },
    /// Send an AV\C passthrough key command.
    /// If `key_pressed`, then the AV\C passthrough command shall be interpreted as a key
    /// press down event. Otherwise, the command shall be interpreted as a key release event.
    SendCommand {
        command: AvcPanelCommand,
        pressed: bool,
        responder: TargetHandlerSendCommandResponder,
    },
    /// Request the target device to provide all the target supported player application
    /// setting attributes.
    ListPlayerApplicationSettingAttributes {
        responder: TargetHandlerListPlayerApplicationSettingAttributesResponder,
    },
    /// Returns currently set player application setting values for the `attribute_ids`.
    /// If no `attribute_ids` are provided, this method will query the TG for all valid
    /// attribute ID's, and return the currently set player application setting values.
    GetPlayerApplicationSettings {
        attribute_ids: Vec<PlayerApplicationSettingAttributeId>,
        responder: TargetHandlerGetPlayerApplicationSettingsResponder,
    },
    /// Sets the player application settings specified by `requested_settings`. Only
    /// settings specified in the input `requested_settings` will be overwritten.
    /// Returns the actual settings that were set.
    /// Settings provided in the `requested_settings` that are unsupported or unknown
    /// will not be set; and `SetPlayerApplicationSettings` will not return an error.
    /// Instead, the returned `set_settings` will include only the settings that were
    /// successfully set on the remote target.
    SetPlayerApplicationSettings {
        requested_settings: PlayerApplicationSettings,
        responder: TargetHandlerSetPlayerApplicationSettingsResponder,
    },
    /// Returns the current value for the notification specified by `event_id`.
    GetNotification {
        event_id: NotificationEvent,
        responder: TargetHandlerGetNotificationResponder,
    },
    /// Returns the changed value of the notification specified by 'event_id'.
    /// A changed value refers to any value that is different than the input parameter
    /// `current` Notification value.
    /// `WatchNotification` will not respond until the Notification value associated
    /// with `event_id` has changed from the `current` Notification.
    WatchNotification {
        event_id: NotificationEvent,
        current: Notification,
        pos_change_interval: u32,
        responder: TargetHandlerWatchNotificationResponder,
    },
    /// Changes the addressed `player_id` on the target when multiple are supported.
    SetAddressedPlayer {
        player_id: AddressedPlayerId,
        responder: TargetHandlerSetAddressedPlayerResponder,
    },
    /// Returns a list of media player information about the players on the target.
    GetMediaPlayerItems { responder: TargetHandlerGetMediaPlayerItemsResponder },
}

impl TargetHandlerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_events_supported(self) -> Option<(TargetHandlerGetEventsSupportedResponder)> {
        if let TargetHandlerRequest::GetEventsSupported { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_media_attributes(self) -> Option<(TargetHandlerGetMediaAttributesResponder)> {
        if let TargetHandlerRequest::GetMediaAttributes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_play_status(self) -> Option<(TargetHandlerGetPlayStatusResponder)> {
        if let TargetHandlerRequest::GetPlayStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_command(
        self,
    ) -> Option<(AvcPanelCommand, bool, TargetHandlerSendCommandResponder)> {
        if let TargetHandlerRequest::SendCommand { command, pressed, responder } = self {
            Some((command, pressed, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_player_application_setting_attributes(
        self,
    ) -> Option<(TargetHandlerListPlayerApplicationSettingAttributesResponder)> {
        if let TargetHandlerRequest::ListPlayerApplicationSettingAttributes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_player_application_settings(
        self,
    ) -> Option<(
        Vec<PlayerApplicationSettingAttributeId>,
        TargetHandlerGetPlayerApplicationSettingsResponder,
    )> {
        if let TargetHandlerRequest::GetPlayerApplicationSettings { attribute_ids, responder } =
            self
        {
            Some((attribute_ids, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_player_application_settings(
        self,
    ) -> Option<(PlayerApplicationSettings, TargetHandlerSetPlayerApplicationSettingsResponder)>
    {
        if let TargetHandlerRequest::SetPlayerApplicationSettings {
            requested_settings,
            responder,
        } = self
        {
            Some((requested_settings, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_notification(
        self,
    ) -> Option<(NotificationEvent, TargetHandlerGetNotificationResponder)> {
        if let TargetHandlerRequest::GetNotification { event_id, responder } = self {
            Some((event_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_notification(
        self,
    ) -> Option<(NotificationEvent, Notification, u32, TargetHandlerWatchNotificationResponder)>
    {
        if let TargetHandlerRequest::WatchNotification {
            event_id,
            current,
            pos_change_interval,
            responder,
        } = self
        {
            Some((event_id, current, pos_change_interval, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_addressed_player(
        self,
    ) -> Option<(AddressedPlayerId, TargetHandlerSetAddressedPlayerResponder)> {
        if let TargetHandlerRequest::SetAddressedPlayer { player_id, responder } = self {
            Some((player_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_media_player_items(
        self,
    ) -> Option<(TargetHandlerGetMediaPlayerItemsResponder)> {
        if let TargetHandlerRequest::GetMediaPlayerItems { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            TargetHandlerRequest::GetEventsSupported { .. } => "get_events_supported",
            TargetHandlerRequest::GetMediaAttributes { .. } => "get_media_attributes",
            TargetHandlerRequest::GetPlayStatus { .. } => "get_play_status",
            TargetHandlerRequest::SendCommand { .. } => "send_command",
            TargetHandlerRequest::ListPlayerApplicationSettingAttributes { .. } => {
                "list_player_application_setting_attributes"
            }
            TargetHandlerRequest::GetPlayerApplicationSettings { .. } => {
                "get_player_application_settings"
            }
            TargetHandlerRequest::SetPlayerApplicationSettings { .. } => {
                "set_player_application_settings"
            }
            TargetHandlerRequest::GetNotification { .. } => "get_notification",
            TargetHandlerRequest::WatchNotification { .. } => "watch_notification",
            TargetHandlerRequest::SetAddressedPlayer { .. } => "set_addressed_player",
            TargetHandlerRequest::GetMediaPlayerItems { .. } => "get_media_player_items",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for TargetHandlerControlHandle {
    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 TargetHandlerControlHandle {}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerGetEventsSupportedResponder {
    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 TargetHandlerGetEventsSupportedResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerGetEventsSupportedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&[NotificationEvent], TargetAvcError>,
    ) -> 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<&[NotificationEvent], TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&[NotificationEvent], TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerGetEventsSupportedResponse,
            TargetAvcError,
        >>(
            result.map(|notification_ids| (notification_ids,)),
            self.tx_id,
            0x54bb8d817d5e1257,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerGetMediaAttributesResponder {
    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 TargetHandlerGetMediaAttributesResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerGetMediaAttributesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&MediaAttributes, TargetAvcError>,
    ) -> 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<&MediaAttributes, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&MediaAttributes, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerGetMediaAttributesResponse,
            TargetAvcError,
        >>(
            result.map(|attributes| (attributes,)),
            self.tx_id,
            0x629f354d2805daf5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerGetPlayStatusResponder {
    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 TargetHandlerGetPlayStatusResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerGetPlayStatusResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&PlayStatus, TargetAvcError>) -> 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<&PlayStatus, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&PlayStatus, TargetAvcError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerGetPlayStatusResponse,
            TargetAvcError,
        >>(
            result.map(|play_status| (play_status,)),
            self.tx_id,
            0x24a4816300e14d89,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerSendCommandResponder {
    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 TargetHandlerSendCommandResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerSendCommandResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), TargetPassthroughError>) -> 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<(), TargetPassthroughError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerListPlayerApplicationSettingAttributesResponder {
    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 TargetHandlerListPlayerApplicationSettingAttributesResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerListPlayerApplicationSettingAttributesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&[PlayerApplicationSettingAttributeId], TargetAvcError>,
    ) -> 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<&[PlayerApplicationSettingAttributeId], TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&[PlayerApplicationSettingAttributeId], TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerListPlayerApplicationSettingAttributesResponse,
            TargetAvcError,
        >>(
            result.map(|attributes| (attributes,)),
            self.tx_id,
            0xdfa38da6a60b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerGetPlayerApplicationSettingsResponder {
    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 TargetHandlerGetPlayerApplicationSettingsResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerGetPlayerApplicationSettingsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&PlayerApplicationSettings, TargetAvcError>,
    ) -> 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<&PlayerApplicationSettings, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&PlayerApplicationSettings, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerGetPlayerApplicationSettingsResponse,
            TargetAvcError,
        >>(
            result.map(|current_settings| (current_settings,)),
            self.tx_id,
            0x4273f96bdb752751,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerSetPlayerApplicationSettingsResponder {
    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 TargetHandlerSetPlayerApplicationSettingsResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerSetPlayerApplicationSettingsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&PlayerApplicationSettings, TargetAvcError>,
    ) -> 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<&PlayerApplicationSettings, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&PlayerApplicationSettings, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerSetPlayerApplicationSettingsResponse,
            TargetAvcError,
        >>(
            result.map(|set_settings| (set_settings,)),
            self.tx_id,
            0x636dd18255e01998,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerGetNotificationResponder {
    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 TargetHandlerGetNotificationResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerGetNotificationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&Notification, TargetAvcError>,
    ) -> 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<&Notification, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&Notification, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerGetNotificationResponse,
            TargetAvcError,
        >>(
            result.map(|current_value| (current_value,)),
            self.tx_id,
            0x60c7792539a032f1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerWatchNotificationResponder {
    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 TargetHandlerWatchNotificationResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerWatchNotificationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&Notification, TargetAvcError>,
    ) -> 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<&Notification, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&Notification, TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerWatchNotificationResponse,
            TargetAvcError,
        >>(
            result.map(|new_value| (new_value,)),
            self.tx_id,
            0x2a513434cf256e5f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerSetAddressedPlayerResponder {
    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 TargetHandlerSetAddressedPlayerResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerSetAddressedPlayerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), TargetAvcError>) -> 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<(), TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`TargetHandlerControlHandle::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 TargetHandlerGetMediaPlayerItemsResponder {
    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 TargetHandlerGetMediaPlayerItemsResponder {
    type ControlHandle = TargetHandlerControlHandle;

    fn control_handle(&self) -> &TargetHandlerControlHandle {
        &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 TargetHandlerGetMediaPlayerItemsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&[MediaPlayerItem], TargetAvcError>,
    ) -> 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<&[MediaPlayerItem], TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&[MediaPlayerItem], TargetAvcError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            TargetHandlerGetMediaPlayerItemsResponse,
            TargetAvcError,
        >>(
            result.map(|items| (items,)),
            self.tx_id,
            0x736668f5aa3a8246,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for PeerManagerGetBrowseControllerForTargetRequest {
        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 PeerManagerGetBrowseControllerForTargetRequest {
        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<
            PeerManagerGetBrowseControllerForTargetRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeerManagerGetBrowseControllerForTargetRequest
    {
        #[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::<PeerManagerGetBrowseControllerForTargetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PeerManagerGetBrowseControllerForTargetRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_bluetooth::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BrowseControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.client),
                ),
                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<BrowseControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PeerManagerGetBrowseControllerForTargetRequest,
            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::<PeerManagerGetBrowseControllerForTargetRequest>(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 PeerManagerGetBrowseControllerForTargetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_id: fidl::new_empty!(
                    fidl_fuchsia_bluetooth::PeerId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                client: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BrowseControllerMarker>>,
                    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.peer_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BrowseControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.client,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PeerManagerGetControllerForTargetRequest {
        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 PeerManagerGetControllerForTargetRequest {
        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<
            PeerManagerGetControllerForTargetRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeerManagerGetControllerForTargetRequest
    {
        #[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::<PeerManagerGetControllerForTargetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PeerManagerGetControllerForTargetRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_bluetooth::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.client),
                ),
                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<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PeerManagerGetControllerForTargetRequest,
            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::<PeerManagerGetControllerForTargetRequest>(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 PeerManagerGetControllerForTargetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_id: fidl::new_empty!(
                    fidl_fuchsia_bluetooth::PeerId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                client: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                    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.peer_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.client,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PeerManagerRegisterTargetHandlerRequest {
        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 PeerManagerRegisterTargetHandlerRequest {
        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<
            PeerManagerRegisterTargetHandlerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeerManagerRegisterTargetHandlerRequest
    {
        #[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::<PeerManagerRegisterTargetHandlerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PeerManagerRegisterTargetHandlerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<TargetHandlerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handler),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<TargetHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PeerManagerRegisterTargetHandlerRequest,
            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::<PeerManagerRegisterTargetHandlerRequest>(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 PeerManagerRegisterTargetHandlerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handler: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<TargetHandlerMarker>>,
                    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<TargetHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handler,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PeerManagerSetAbsoluteVolumeHandlerRequest {
        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 PeerManagerSetAbsoluteVolumeHandlerRequest {
        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<
            PeerManagerSetAbsoluteVolumeHandlerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeerManagerSetAbsoluteVolumeHandlerRequest
    {
        #[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::<PeerManagerSetAbsoluteVolumeHandlerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PeerManagerSetAbsoluteVolumeHandlerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handler
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PeerManagerSetAbsoluteVolumeHandlerRequest,
            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::<PeerManagerSetAbsoluteVolumeHandlerRequest>(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 PeerManagerSetAbsoluteVolumeHandlerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handler: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AbsoluteVolumeHandlerMarker>,
                    >,
                    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<AbsoluteVolumeHandlerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handler,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }
}